{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch Normalization\n",
    "使深层网络更容易训练的一种方法是使用更复杂的优化过程，如SGD+momentum、RMSProp或Adam。另一个策略是改变网络的结构，使其更容易培训。这方面的一个想法是批量标准化，这是最近由[3]提出的。\n",
    "\n",
    "这个想法相对简单。当输入数据由零均值和单位方差的不相关特征组成时，机器学习方法的效果往往更好。在训练神经网络时，我们可以先对数据进行预处理，然后再将其输入网络，以显式地去关联其特征;这将确保网络的第一层能够看到遵循良好分布的数据。然而，即使我们对输入数据进行预处理，网络较深层的活动也可能不再具有去相关性，也不再具有零均值或单位方差，因为它们是从网络较早的层中输出的。更糟糕的是，在训练过程中，网络每一层的特征分布会随着每一层权重的更新而改变。\n",
    "\n",
    "[3]的作者假设，深层神经网络内部特征分布的变化可能使深层神经网络的训练更加困难。为了克服这个问题，[3]建议将批处理规范化层插入到网络中。在训练时，批处理归一化层使用小批数据估计每个特征的均值和标准差。这些估计的平均值和标准偏差然后用于中心和标准化的特征的小批量。在训练期间，这些平均值和标准偏差的运行平均值被保持，在测试时，这些运行平均值被用来集中和标准化特征。\n",
    "\n",
    "这种归一化策略可能会降低网络的表示能力，因为有时某些层的特征不是零均值或单位方差的，这可能是最优的。为此，批处理规范化层包括每个特征维的可学习的移位和缩放参数。\n",
    "\n",
    "[3] Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n",
    "Internal Covariate Shift\", ICML 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train:  (49000, 3, 32, 32)\n",
      "y_train:  (49000,)\n",
      "X_val:  (1000, 3, 32, 32)\n",
      "y_val:  (1000,)\n",
      "X_test:  (1000, 3, 32, 32)\n",
      "y_test:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in data.items():\n",
    "  print('%s: ' % k, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 批量标准化：前向传递\n",
    "在文件 `cs231n/layers.py`函数`batchnorm_forward`中实现批量标准化前向传递。完成之后，运行以下代码来测试您的实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before batch normalization:\n",
      "  means:  [ -2.3814598  -13.18038246   1.91780462]\n",
      "  stds:  [27.18502186 34.21455511 37.68611762]\n",
      "After batch normalization (gamma=1, beta=0)\n",
      "  mean:  [5.32907052e-17 7.04991621e-17 4.22578639e-17]\n",
      "  std:  [0.99999999 1.         1.        ]\n",
      "After batch normalization (nontrivial gamma, beta)\n",
      "  means:  [11. 12. 13.]\n",
      "  stds:  [0.99999999 1.99999999 2.99999999]\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after batch normalization\n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before batch normalization:')\n",
    "print('  means: ', a.mean(axis=0))\n",
    "print('  stds: ', a.std(axis=0))\n",
    "\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After batch normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = batchnorm_forward(a, np.ones(D3), np.zeros(D3), {'mode': 'train'})\n",
    "print('  mean: ', a_norm.mean(axis=0))\n",
    "print('  std: ', a_norm.std(axis=0))\n",
    "\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "gamma = np.asarray([1.0, 2.0, 3.0])\n",
    "beta = np.asarray([11.0, 12.0, 13.0])\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print('After batch normalization (nontrivial gamma, beta)')\n",
    "print('  means: ', a_norm.mean(axis=0))\n",
    "print('  stds: ', a_norm.std(axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After batch normalization (test-time):\n",
      "  means:  [-0.03927354 -0.04349152 -0.10452688]\n",
      "  stds:  [1.01531428 1.01238373 0.97819988]\n"
     ]
    }
   ],
   "source": [
    "# Check the test-time forward pass by running the training-time\n",
    "# forward pass many times to warm up the running averages, and then\n",
    "# checking the means and variances of activations after a test-time\n",
    "# forward pass.\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "for t in range(50):\n",
    "  X = np.random.randn(N, D1)\n",
    "  a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "  batchnorm_forward(a, gamma, beta, bn_param)\n",
    "bn_param['mode'] = 'test'\n",
    "X = np.random.randn(N, D1)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "# Means should be close to zero and stds close to one, but will be\n",
    "# noisier than training-time forward passes.\n",
    "print('After batch normalization (test-time):')\n",
    "print('  means: ', a_norm.mean(axis=0))\n",
    "print('  stds: ', a_norm.std(axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 批处理标准化:后向传递\n",
    "现在在函数`batchnorm_backwards`中实现批处理规范化的后向遍历。\n",
    "要获得向后传递，您应该写出批处理规范化的计算图，并通过每个中间节点进行支持。一些中间体可能有多个传出分支;确保在后向遍历中对这些分支的梯度求和。\n",
    "一旦你完成了，运行下面的数字检查你的向后通过。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.7029241291468676e-09\n",
      "dgamma error:  7.420414216247087e-13\n",
      "dbeta error:  2.8795057655839487e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "fx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
    "fg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\n",
    "fb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "dx, dgamma, dbeta = batchnorm_backward(dout, cache)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 批处理标准化:可选向后(可选，+3分额外学分)\n",
    "在课堂上，我们讨论了sigmoid向后传递的两种不同实现。一种策略是通过所有中间值写出由简单操作和支撑组成的计算图。另一种策略是在纸上计算出衍生品。对于sigmoid函数，可以通过在纸上简化梯度得到一个非常简单的后向遍历公式。\n",
    "令人惊讶的是，如果您在纸上计算导数并进行简化，您还可以得到一个简单的表达式，用于批处理规范化的反向传递。这样做之后，在函数`batchnorm_backward_alt`中实现简化的批处理规范化后向传递，并通过运行以下代码比较这两个实现。您的两个实现应该计算几乎相同的结果，但是另一个实现应该更快一些。\n",
    "注:这部分作业是完全可选的，但如果你能完成，我们将奖励3分的额外学分。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx difference:  1.0475263156312713e-10\n",
      "dgamma difference:  0.0\n",
      "dbeta difference:  0.0\n",
      "speedup: 4.01x\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D = 100, 500\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "out, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "\n",
    "t1 = time.time()\n",
    "dx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\n",
    "t2 = time.time()\n",
    "dx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\n",
    "t3 = time.time()\n",
    "\n",
    "print('dx difference: ', rel_error(dx1, dx2))\n",
    "print('dgamma difference: ', rel_error(dgamma1, dgamma2))\n",
    "print('dbeta difference: ', rel_error(dbeta1, dbeta2))\n",
    "print('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 全连接网络与批量标准化\n",
    "现在您已经有了批处理规范化的工作实现，回到文件`cs2312n/classifier /fc_net.py`中的`FullyConnectedNet`。修改您的实现以添加批处理规范化。\n",
    "具体来说，当构造函数中的`use_batchnorm `标记为`True`时，应该在每个ReLU非线性之前插入一个批处理规范化层。网络最后一层的输出不应该被规范化。完成之后，运行以下步骤来逐步检查实现。\n",
    "提示:您可能会发现定义一个类似于文件`cs231n/layer_utils.py`中的附加帮助层很有用。如果您决定这样做，请在`cs231n/classifiers/fc_net.py`文件中执行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.2611955101340957\n",
      "W1 relative error: 1.10e-04\n",
      "W2 relative error: 2.85e-06\n",
      "W3 relative error: 3.92e-10\n",
      "b1 relative error: 4.44e-08\n",
      "b2 relative error: 2.22e-08\n",
      "b3 relative error: 4.78e-11\n",
      "beta1 relative error: 7.33e-09\n",
      "beta2 relative error: 1.89e-09\n",
      "gamma1 relative error: 7.57e-09\n",
      "gamma2 relative error: 1.96e-09\n",
      "\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  6.996533220108303\n",
      "W1 relative error: 1.98e-06\n",
      "W2 relative error: 2.28e-06\n",
      "W3 relative error: 1.11e-08\n",
      "b1 relative error: 5.55e-09\n",
      "b2 relative error: 5.55e-09\n",
      "b3 relative error: 2.23e-10\n",
      "beta1 relative error: 6.65e-09\n",
      "beta2 relative error: 3.48e-09\n",
      "gamma1 relative error: 5.94e-09\n",
      "gamma2 relative error: 4.14e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64,\n",
    "                            use_batchnorm=True)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
    "  if reg == 0: print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 深度网络的批量标准化\n",
    "运行以下命令，在1000个训练示例的子集上训练一个六层网络，包括有和没有批处理规范化的示例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 200) loss: 2.340974\n",
      "(Epoch 0 / 10) train acc: 0.101000; val_acc: 0.112000\n",
      "(Epoch 1 / 10) train acc: 0.244000; val_acc: 0.211000\n",
      "(Epoch 2 / 10) train acc: 0.345000; val_acc: 0.283000\n",
      "(Epoch 3 / 10) train acc: 0.405000; val_acc: 0.293000\n",
      "(Epoch 4 / 10) train acc: 0.437000; val_acc: 0.294000\n",
      "(Epoch 5 / 10) train acc: 0.486000; val_acc: 0.301000\n",
      "(Epoch 6 / 10) train acc: 0.538000; val_acc: 0.321000\n",
      "(Epoch 7 / 10) train acc: 0.606000; val_acc: 0.322000\n",
      "(Epoch 8 / 10) train acc: 0.607000; val_acc: 0.325000\n",
      "(Epoch 9 / 10) train acc: 0.663000; val_acc: 0.341000\n",
      "(Epoch 10 / 10) train acc: 0.710000; val_acc: 0.333000\n",
      "(Iteration 1 / 200) loss: 2.302332\n",
      "(Epoch 0 / 10) train acc: 0.155000; val_acc: 0.140000\n",
      "(Epoch 1 / 10) train acc: 0.182000; val_acc: 0.160000\n",
      "(Epoch 2 / 10) train acc: 0.213000; val_acc: 0.178000\n",
      "(Epoch 3 / 10) train acc: 0.237000; val_acc: 0.229000\n",
      "(Epoch 4 / 10) train acc: 0.265000; val_acc: 0.237000\n",
      "(Epoch 5 / 10) train acc: 0.304000; val_acc: 0.251000\n",
      "(Epoch 6 / 10) train acc: 0.334000; val_acc: 0.264000\n",
      "(Epoch 7 / 10) train acc: 0.357000; val_acc: 0.259000\n",
      "(Epoch 8 / 10) train acc: 0.365000; val_acc: 0.221000\n",
      "(Epoch 9 / 10) train acc: 0.385000; val_acc: 0.236000\n",
      "(Epoch 10 / 10) train acc: 0.411000; val_acc: 0.267000\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [100, 100, 100, 100, 100]\n",
    "\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 2e-2\n",
    "bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=True)\n",
    "model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=False)\n",
    "\n",
    "bn_solver = Solver(bn_model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True, print_every=200)\n",
    "bn_solver.train()\n",
    "\n",
    "solver = Solver(model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True, print_every=200)\n",
    "solver.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行以下命令来可视化上面训练的两个网络的结果。您应该会发现，使用批处理规范化有助于网络更快地收敛。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Python\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:13: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  del sys.path[0]\n",
      "D:\\Python\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:17: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "D:\\Python\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:21: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "D:\\Python\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:26: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3AAAANsCAYAAAAa/ko3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzde5xV9Xkv/s8zF2TwwhghMcxAoT0eEwsoZtREPKnKT8GoSD0pMV5imvrCJjFWmwOOaWoIaY9TOYmJaa2h1CZ5aRRiFDHYgoa0FmsSQBA1hhgvCTDeQEdFxs7t+f2x9x7W7FnXvb5rre9a+/N+vXzhrNmX7157bfg++3m+z1dUFURERERERGS/hqwHQEREREREROEwgCMiIiIiIsoJBnBEREREREQ5wQCOiIiIiIgoJxjAERERERER5QQDOCIiIiIiopxgAEdERIUhIo0isl9Eppi8bQ3j+BsR+a7pxyUiImrKegBERFS/RGS/48dxAP4bwGD55ytV9c4oj6eqgwAOM31bIiIiWzCAIyKizKjqcAAlIi8CuEJVH/a6vYg0qepAGmMjIiKyEUsoiYjIWuVSxFUicpeIvA3gUhH5iIj8TER6ROQlEblFRJrLt28SERWRqeWf7yj//l9F5G0ReUxEpkW9bfn354jIr0XkTRH5tog8KiKfDvk6FojI0+UxbxSRYx2/+5KIdIvIWyLyKxE5vXz8wyLyePn4KyKy3MApJSKinGMAR0REtvtjAD8AMB7AKgADAP4CwAQAswHMA3Clz/0vBvDXAN4D4HcAvhb1tiLyXgCrASwuP+8LAE4OM3gR+SCAOwB8AcBEAA8DeEBEmkXkD8tjP1FVjwBwTvl5AeDbAJaXj/8PAPeEeT4iIio2BnBERGS7Tar6gKoOqWqvqm5W1Z+r6oCqPg9gBYA/8rn/Paq6RVX7AdwJ4IQabnsegO2qen/5dzcD2Bty/BcBWKuqG8v37QJwBIBTUApGxwL4w3J56Avl1wQA/QCOEZGjVPVtVf15yOcjIqICYwBHRES22+X8QUQ+ICLrRORlEXkLwDKUsmJeXnb8/wH4Ny7xuu0k5zhUVQHsDjH2yn1/67jvUPm+baq6E8AXUXoNr5ZLRY8u3/RPARwHYKeI/EJEPhby+YiIqMAYwBERke206ufvAHgKwP8olxfeAEASHsNLANorP4iIAGgLed9uAL/nuG9D+bH2AICq3qGqswFMA9AI4Mby8Z2qehGA9wL4OoAficjY+C+FiIjyjAEcERHlzeEA3gTwTnl9md/6N1N+DOBEETlfRJpQWoM3MeR9VwOYLyKnl5utLAbwNoCfi8gHReQMETkEQG/5v0EAEJHLRGRCOWP3JkqB7JDZl0VERHnDAI6IiPLmiwAuRykI+g5KjU0SpaqvAPgEgG8A2AfgDwBsQ2nfuqD7Po3SeP8RwGsoNV2ZX14PdwiAm1BaT/cygCMBfLl8148BeKbcffP/AfiEqvYZfFlERJRDUirjJyIiorBEpBGl0siPq+p/Zj0eIiKqH8zAERERhSAi80RkfLnc8a9R6iD5i4yHRUREdYYBHBERUTinAXgepXLHeQAWqGpgCSUREZFJLKEkIiIiIiLKCWbgiIiIiIiIcqIp6wG4mTBhgk6dOjXrYRAREREREWVi69ate1V11JY1VgZwU6dOxZYtW7IeBhERERERUSZE5Ldux1lCSURERERElBMM4IiIiIiIiHKCARwREREREVFOWLkGjoiI3PX392P37t149913sx4KUSxjx45Fe3s7mpubsx4KEVGuMIAjIsqR3bt34/DDD8fUqVMhIlkPh6gmqop9+/Zh9+7dmDZtWtbDISLKFZZQEhHlyLvvvoujjjqKwRvlmojgqKOOYiaZiKgGzMBZbM22PVi+fie6e3oxqbUFi+ceiwWz2rIeFhFljMEbFQGvYyKi2jCAs9SabXtw/b1Pord/EACwp6cX19/7JAAwiCMiIiIiqlMsobTU8vU7h4O3it7+QSxfvzOjERERlbz44ouYPn16Io/97//+7zjvvPMAAGvXrkVXV1ciz5MHUc/zd7/7XXR3dwfe5qqrroo7NCIiyhAzcJbq7umNdJyIyE2eS7Hnz5+P+fPnZz2McHasBn6yDHhzNzC+HZhzAzBzYapD+O53v4vp06dj0qRJqT4vAAwMDKCpiVMKIqI0MANnqUmtLZGOExFVq5Ri7+npheJgKfaabXtiP/bAwAAuv/xyzJw5Ex//+Mdx4MABLFu2DCeddBKmT5+ORYsWQVUBALfccguOO+44zJw5ExdddBEA4J133sFnPvMZnHTSSZg1axbuv//+Uc/hzBZ9+tOfxtVXX41TTz0Vv//7v4977rln+HbLly/HSSedhJkzZ+IrX/lK7NcW2Y7VwANXA2/uAqClPx+4unQ8prDn+Z577sGWLVtwySWX4IQTTkBvby82b96MU089FccffzxOPvlkvP322wCA7u5uzJs3D8cccwyWLFky/FyHHXYY/uqv/grHH388PvzhD+OVV14BAPz2t7/FnDlzMHPmTMyZMwe/+93vAJTek7/8y7/EGWecgeuuuw5Lly7F5ZdfjrPPPhtTp07FvffeiyVLlmDGjBmYN28e+vv7Y58PIiJiAGetxXOPRUtz44hjLc2NWDz32IxGRER5k2Qp9s6dO7Fo0SLs2LEDRxxxBG699VZcddVV2Lx5M5566in09vbixz/+MQCgq6sL27Ztw44dO3DbbbcBAP72b/8WZ555JjZv3oyf/vSnWLx4Md555x3f53zppZewadMm/PjHP0ZnZycAYMOGDXj22Wfxi1/8Atu3b8fWrVvxyCOPxH59kfxkGdBfVR3R31s6HlPY8/zxj38cHR0duPPOO7F9+3Y0NjbiE5/4BL71rW/hiSeewMMPP4yWltIXgNu3b8eqVavw5JNPYtWqVdi1axeAUlD94Q9/GE888QQ++tGP4p/+6Z8AAFdddRU+9alPYceOHbjkkktw9dVXD4/v17/+NR5++GF8/etfBwA899xzWLduHe6//35ceumlOOOMM/Dkk0+ipaUF69ati30+iIgoRAAnIpNF5Kci8oyIPC0if+Fym9NF5E0R2V7+7wbH7+aJyE4R+Y2IdJp+AUW1YFYbbrxwBtpaWyAA2lpbcOOFM3JT+kRE2UuyFHvy5MmYPXs2AODSSy/Fpk2b8NOf/hSnnHIKZsyYgY0bN+Lpp58GAMycOROXXHIJ7rjjjuEyuw0bNqCrqwsnnHACTj/9dLz77rvDmR0vCxYsQENDA4477rjh7NCGDRuwYcMGzJo1CyeeeCJ+9atf4dlnn439+iJ5c3e04xFEOc9OO3fuxPvf/36cdNJJAIAjjjhi+NzPmTMH48ePx9ixY3Hcccfht7/9LQBgzJgxw+sPP/ShD+HFF18EADz22GO4+OKLAQCXXXYZNm3aNPw8f/Inf4LGxoNfNp5zzjlobm7GjBkzMDg4iHnz5gEAZsyYMfx4REQUT5iC9QEAX1TVx0XkcABbReQhVf1l1e3+U1XPcx4QkUYA/wDgLAC7AWwWkbUu9yUXC2a1MWAjoppNam3BHpdgzUQpdnULeBHB5z73OWzZsgWTJ0/G0qVLh/f4WrduHR555BGsXbsWX/va1/D0009DVfGjH/0Ixx47sqqgEpi5OeSQQ4b/v1Keqaq4/vrrceWVV8Z+TTUb314un3Q5HlOU8+ykqp5t+p3nsbGxEQMDAwCA5ubm4fs4j/uN6dBDD3V97IaGhhGP19DQ4Pl4REQUTWAGTlVfUtXHy///NoBnAISNKk4G8BtVfV5V+wDcDeCCWgdLREThJVmK/bvf/Q6PPfYYAOCuu+7CaaedBgCYMGEC9u/fP7xGbWhoCLt27cIZZ5yBm266CT09Pdi/fz/mzp2Lb3/728OB2LZt22oax9y5c3H77bdj//79AIA9e/bg1VdfjfvyoplzA9BcFRQ3t5SOxxT2PAPA4YcfPrzO7QMf+AC6u7uxefNmAMDbb79dcwB16qmn4u677wYA3HnnncNjICKibERqGSUiUwHMAvBzl19/RESeANAN4P+o6tMoBXrOryV3AzjF47EXAVgEAFOmTIkyLCIiclHJ4CfRhfKDH/wgvve97+HKK6/EMcccg89+9rN44403MGPGDEydOnW4dG9wcBCXXnop3nzzTagqrr32WrS2tuKv//qvcc0112DmzJlQVUydOnV4zVwUZ599Np555hl85CMfAVBqxHHHHXfgve99b+zXGFql22QCXSjDnmeg1FTkz//8z9HS0oLHHnsMq1atwhe+8AX09vaipaUFDz/8cE1juOWWW/CZz3wGy5cvx8SJE/Ev//IvsV8XERHVTirffgbeUOQwAP8B4G9V9d6q3x0BYEhV94vIxwB8S1WPEZE/ATBXVa8o3+4yACer6hf8nqujo0O3bNlSw8shIiq2Z555Bh/84AezHgaREbyeiYi8ichWVe2oPh4qAycizQB+BODO6uANAFT1Lcf/Pygit4rIBJQybpMdN21HKUNXGHneY4mIiIiIiPIlMICT0grkfwbwjKp+w+M2RwN4RVVVRE5GaW3dPgA9AI4RkWkA9gC4CMDFpgaftcoeS5U23ZU9lgAwiCMiIiIiIuPCZOBmA7gMwJMisr187EsApgCAqt4G4OMAPisiAwB6AVykpdrMARG5CsB6AI0Abi+vjSsEvz2WGMARUVL8OgwS5UXYJRxERDRSYACnqpsA+M4UVPXvAfy9x+8eBPBgTaOzXJJ7LBERuRk7diz27duHo446ikEc5ZaqYt++fRg7dmzWQyEiyp1IXShppCT3WCIictPe3o7du3fjtddey3ooRLGMHTsW7e3x98ojIqo3DOBiWDz32BFr4ABzeywREblpbm7GtGnTsh4GERERZYQBXAxJ7rFERERERERUjQFcTAtmtTFgIyIiIiKiVDRkPQAiIiIiIiIKhwEcERERERFRTjCAIyIiIiIiygkGcERERERERDnBJiY5smbbHna8JCIiIiKqYwzgcmLNtj0j9pzb09OL6+99EgAYxFHh8MsKIiIiIncsoQxjx2rg5unA0tbSnztWpz6E5et3jtgwHAB6+wexfP3O1MdClKTKlxV7enqhOPhlxZpte7IeGhEREVHmGMAF2bEaeOBq4M1dALT05wNXpx7Edff0RjpOlFf8soKIiIjIGwO4ID9ZBvRXBUn9vaXjKZrU2hLpuGlrtu3B7K6NmNa5DrO7NjIbQonhlxVERERE3hjABXlzd7TjCVk891i0NDeOONbcIDjQN1BTUBUlIGNJG6Up6y8riIiIiGzGAC7I+PZoxxOyYFYbbrxwBtpaWyAAWluaAQHeONAfOaiKGpCxpI3S5PZlRUtzIxbPPTajERERERHZgwFckDk3YKBx7IhDCpTWwrk0NAnKbMUpRVwwqw2Pdp6JF7rOxaGHNKF/UEf8PmxQtXz9Tpw1+B/YNOZqPH/Ixdg05mqcNfgfnvdlSRulqfrLirbWFtx44Qx2oSQiIiICtxEItGZwNjb1X4FrcDcmyV4AQIOUf/nmLgze91k0/ut1QO8bONByNDa987+xp+9UAKXM1uIfPoGvPvA0eg70Y3xLM97pGxgOvKq3AojSOj1OUNXx1kO4sXklxkkfAKBd9qKreSWufwsAzhx1+0mtLdjj8rgsaaOkLJjVxoCNiIiIyAUzcAGWr9+Je/pOxWl9t6BbJxwM3soadQDofR2AYlzvS1gmKzC/YdPw7/uHdLjMsae33zNrFrWsMc46oevH/HA4eKsYJ324fswPXW/PkjYiIiIiIjswgAvgzGhVMnB+xkkfljRF22Kgu6c38jqzOEHV++D+OryOs6SNiIiIiMgOLKEM4Cwf7NYJaA8RxE2SfZ6/m9+wCUuaVmOS7EW3TsBNAwux9YizIpdEVoKnsCWXTjK+vbyvnctxDyxpo2pRSn6JiIiIyAxm4AI4M103DSzEAR0TeJ9uPcr1+PyGTehqXon2hr1oEKC9YS/+rnklvnncszWVRDqbmjzaWVq7FqpBypwbgOaqx21uKR0nCoFbSxARERFlIzCAE5HJIvJTEXlGRJ4Wkb9wuc0lIrKj/N9/icjxjt+9KCJPish2Edli+gUkzVk+uHboNFzffwV2D03AkAr2DR2GPh2ZxBxoHIuVYy4dbvXf3Hhw0dySptWj1p61SB9Oeu7bsdeZRZpQz1wInH8LMH4yACn9ef4tpeNkRNE3PufWEkRERETZCFNCOQDgi6r6uIgcDmCriDykqr903OYFAH+kqm+IyDkAVgA4xfH7M1Q1uPbQUs7ywTXbTsAn1p81XDb2zeOexUnPfbu0sff4djTNuQFLZy7E0vJ9R5SZNXiUVr65O1ZJZOV+XhNq18eYuZABW0IqwXTl/ajuNloE3FqCiIiIKBuBAZyqvgTgpfL/vy0izwBoA/BLx23+y3GXnwFId5frFI1eC3YmgCvD3f5m97VnlU3B46wzy/OEumhrqSIH0znErSWIiIiIshGpiYmITAUwC8DPfW72ZwD+1fGzAtggIgrgO6q6wuOxFwFYBABTpkyJMiy77FgN/GTZcEYOx5wNPLuh9HPLkUDjGGDQUUZpaO1ZXifURcxW5TmYDmvx3GNHvG8At5YgIiIiSkPoJiYichiAHwG4RlXf8rjNGSgFcNc5Ds9W1RMBnAPg8yLyUbf7quoKVe1Q1Y6JEyeGfgFW2bEaeODqcpZNS39u+eeDP/e+DqgCLe+B6bVnQWvobF2TVcS1VHH26MsLbi1BRERElI1QGTgRaUYpeLtTVe/1uM1MACsBnKOqw4u9VLW7/OerInIfgJMBPBJ34Fb6yTKgPyDLMtQPjDkUuO4Fo0/tt4bO5ixX0tmqLMoz6yU7xa0liIiIiNIXGMCJiAD4ZwDPqOo3PG4zBcC9AC5T1V87jh8KoKG8du5QAGcDWGZk5DZ6c3fk25kMMLwm1DavyYpb+ul3/tZs24NN992KVbgbkw7Zi+4DE/DN+y4C8LlEX3fchjRESSvaulMiIqJ6EiYDNxvAZQCeFJHt5WNfAjAFAFT1NgA3ADgKwK2leA8DqtoB4H0A7isfawLwA1X9N6OvwCYeG2S73g7prf+yeU1WnGxV0Pnbvm4FlsmK4a0b2mUvlukK3LSuCQtmfTWBV3MQs1NkK5sz8kRERBQsTBfKTQAk4DZXALjC5fjzAI4ffY+CmnNDaQ2cXxmlo2lJWpmxpBucxPk2P062Kuj8XdF3B8Y1jNx3b5z04Yq+OwAkG8AR2crmjDwREREFi9SFkgJUmpF4daEc314K3sq3SyszluSaLBPf5tearQo6f1777nnux0dUB2zOyBMREVEwBnCmRdgguzozNr9hE5Y0rS4FGDePDPbiSHJNVpbf5gdlFt9tORrjel8a9ft3W47GuERHRmSvvG45QkRERCWhtxEg85yt/+c3bEJX80q0N+xFQ2ULggeuLm1NYMCCWW14tPNMvNB1Lh7tPNNYcJXlt/lBWyeMO2cZBhrHjvj9QONYjDvHwj46O1YDN08HlraW/jT0vhNVC/rcEBERkd2YgcuQMzO25MDq4WYbw/p7S+WYNWbhoqxNq3UdW5bf5gdmFmcuLF3gjpLWJp+sZmad+Sr7B1bWTlaC9/JroGTVW0dGdkklIiLKN1HVrMcwSkdHh27ZsiXrYaRjx+pygOHVvVKApT2RH7Z6bRpQ+pbdbbPlKLcN8zzNDYLDxjah50B/biaHcc5B5f41T4hvnu7+/o+fDFz7VNiXQDWI+74TERERJUVEtpY7+4/AEsosVTIvflsPlLcciMpvbVqc21ZbMKsNN144A22tLRAArS3NgABvHOiH4mBTkzXb9tT0OtIS5xxUgoA9Pb21vWav/QPD7itINYvzvhMRERFlgSWUWfrJstBbDkQVZW1aqNsOZwpHd9N0dpGc3bURPb39Ix7H1hblzqyZVx46zFq+2I1cvPYPDBm811sJoEnsyEhERER5wwAuS34ZlvGTS1sQ/GQZcO+iUUFTkCgdLgPXsUVYo2V6QlwdnJzxgYn46a9e8wxWwgYzbqVzbsKs5Yv9mt32DwwZvHNT5njYkZGIiIjyhiWUWfLKsIyfXJq8P/GDcmYmelfKKB0uA7vSuWUK+3ux+57rMbtr44hSQa+Jby0TYrfSxDt+9jvPUsUopYxuWbNqYTvzxX7NMxcC599Set8hpT/PvyVUsM4SwHjYkZGIiIjyhgFclubcUMq0OFUyLx5BE34SrgW+c23akiafDpcYvY6trbUF//tDbVi+fiemda7DkEemcJLsGxUkmZwQhwmynMFKUDCzZtsezO7aiGmd61yzLhWVcxC2kUUtr9k5ltldG7FmcHapYcnSntKfITOtLAGMx+3aZwMTIiIishlLKLNUmaS7rS27d5H7fSI0thhem7Z0X+BjOdexVZfldQ8dhfaGvaPu3q1HARi53stki/KwQUjldn7BTNiSybbWFjzaeWakcUZ9zSbLHlkCGJ/zuiUiIiKyHQO4rM1c6J5tCdPYwqexSOTHcqjOZN00sBBdzStHZPEO6BjcNHDwuZzBU/WEuJJtMrXHnNvt/G4/qbXFaMmkmyhBQOymJw6L5x7r2gafJYBERERExcQSSlv5lVcCVVsQBKyRC3qsKtWZrLVDp6Gz/wrsHpqAIQh2D01AZ/8VWDt02vBtvDI+cVrsu5UmVnMGK36ljH7ZvLClc86yxxO+ugGzlm04WAIZYZsEk2WPLAEkIiIiqi/MwNnKr7yyctxrjVzlNs4MXcuRQFML0PtGYEdLt0zW2qHTsHXcWQczPkPhMj5e2aYvrn4C167a7puRcytN9OtC6VfKuHz9TtfsXNiSyeqyR+dWCVFLIIPKHqNuCxAl+8ctB4iIiIjyTVS9dsDKTkdHh27ZsiXrYdhtaSvgunuZlBphVLf+B0pZtxDdDd3Wi7U0Nw5ndqIEAdM613nuseb22JGFLCMNek1BZndtDCznrDUYdI4FQKxx1vq8DOKIiIiI7CIiW1W1o/o4M3B5FbSuLUyGzsOCWW1o2/VjTH58Od6rr+FVmYhdJy7GSbPmDf8+7ITfLds0vCed7EW3TsBNAwuxfP2Y6EFEhP3p4jZXCVPeGLYE0m8ss7s2GlsfV83k2jsiIiIiygYDuLwK2vzZq1tlmC6WO1bjpCe/AqAXEOBovIajn/wKMPXI0O3tK6qbbFT2pKs0RGmXvehqXonr3wKAaN0fowapcboNhmmoEqXzo9dYktwWgFsOhMMyUyIiIrIZm5jkldvmz8dfXApelrYC4vHWem0e7hRzDzqn6iYb1zWP3pNunPTh+jE/BOCyP5pfc5A4QWpEQQ1VTHV+NLkRepqPXRRxmu4QERERpYEZuDxzbkFQXU6oLi3zfTpPjmA4MHJmm3TpJa63eR/2Rt8fLeL2CHFUlz2Ob2mGCNBzoN9olibJbQFs23LAxkxX1mWmUc6JjeePiIiIkscArijcsmYAII2ADgV2nhwhwcBIPB5bxrdHnzwHlZEalsaGzyY3Qk/zsaMyuZl52OcL87qzLDONck7SPn9ERERkj8AATkQmA/g+gKMBDAFYoarfqrqNAPgWgI8BOADg06r6ePl3lwP4cvmmf6Oq3zM3/Drj13HRKzumQ6WulFEEBUZhNxCP+NjdP4g4eQ7aaiGnqgPFzWu/g5fvr2ooM/9KI4+dlTQzXVGCnaAtHpIU5ZxknSkkIiKi7ITJwA0A+KKqPi4ihwPYKiIPqeovHbc5B8Ax5f9OAfCPAE4RkfcA+AqADpR63m8VkbWq+obRV1EPgjouxs2aVQdlx18MPLthdGAUofOjK5+ga9KD7q36fSfPzjJSi9Va7rZ57XcwfeuX0SJ9ww1lxm/9MjYDNQdxNjCd6fI7v1GCnSzLTKOcEzakKTaWxxIRkZ/AAE5VXwLwUvn/3xaRZwC0AXAGcBcA+L6WNpX7mYi0isj7AZwO4CFVfR0AROQhAPMA3GX0VdSDoI6LccoJ3YKyJ37gvmdcjO0JhnkEXYvnHotN992Ka3D38BYD38RFOG3u58I9rmGmJlFxyt0mP768FLw5tEgfJj++HMhxAGcy0xV0fqMEO1mWmUY5J163bRDBtM51nPTnGMtjiYgoSKQulCIyFcAsAD+v+lUbAGf6Z3f5mNdxiiqosYhbV8oQm3YDiNZ1MsHOjwsaH0VX80q0N+xFgwDtDaUtBhY0Phr7sUPZsRq4eTqwtBUH/u4D2HTfrUa6EfplgIK8V1/zOL438jhs4tbVs9ZMl9f5/eLqJzCtcx0aRFzv5xUsLpjVhkc7z8QLXecOb8weujNqDFHOiVdX1EFVds/MAb9uu3H+viAiovoQuomJiBwG4EcArlHVt6p/7XIX9Tnu9viLACwCgClTpoQdVv0IUyJZazlhlKAsyc6PP1mGpsF3RxxqGnw3WnavVlVZyHG9L2GZrEBfwxDWDp0GoPY1RnHK3V6ViTgao4O4V2UCjo40itrEyUL63ddkpsvrPA6qjvjTKWywmGY2JMo5qb5tg8io18k1cXYymTEmIqL6FCqAE5FmlIK3O1X1Xpeb7AYw2fFzO4Du8vHTq47/u9tzqOoKACsAoKOjwzXIq2tJdlyMEpQlOY4U93UbxSULOU76sKRpNdb2nTZ8rJZJVJxywV0nLsb4yhq4sl4dg10fWuwZwJkKusa3NOOdvgH0D5Y+jlGCF7dJ6uIfPoGvPvD0iK0XKhmuOMJssg4AjSIYUo10TtJuFhKlyYzzttM617nehpN++wRdU1k20iEionwILKEsd5j8ZwDPqOo3PG62FsCnpOTDAN4sr51bD+BsETlSRI4EcHb5GEUVp0QyyJwbSkGYk1dQlsQ4KqWL7snZRPZ1G8UjSJwk+0b+XMMkKk654Enzr8RTH/obvIyJGFLBy5iIpz70N54NTOJsRF19357e/uHgrSJsKZfbJLV/SPHGgX7jJX5Bm6xXDKkOl0WGDZLykg3hJu35EXRNmSwvJiKiYgqTgZsN4DIAT4rI9vKxLwGYAgCqehuAB1HaQuA3KG0j8Kfl370uIl8DsLl8v2WVhiZUg6Q6LkZtx29yHNUNVKoluK/bCB5ZyG49antjMpEAACAASURBVPj/a51ExS0XPGn+lcMNS44u/+clTsbI7b5uvCagzuxdmBS6qUxWmHJCoLZgJi/ZENs2aTeliN0Yg64pm/ZrtEURrwMiojjCdKHcBPe1bM7bKIDPe/zudgC31zQ6Sk9W7fi9NiAHStm9tPZ1cykNHWgci5VNl0L6EHvSkNb+a3EyRmGzSm7BS3XJZFhhnzNoAuc8v25jcQYzUSaDeQmMijjpL2o3xjDXlC37NdqgqNcBEVEcoZuYECXCc32bANc+ld44XLKQTXNuwNKZC7E0vVHEFidjFGYtmVfwEjZ7V8u41mzbg0333YpVuBuTDtmL7gMT8B/3zcKBDU9hXO/LozLGfsFM1MlgngKjok36i7pZeZ6uKRsU9TogIoqDARyZV70puF8WLcmullHlZFNwP1EzRtVNS5obZcS6t+YGwWFjm0Y0HnGbNPll0gQY1RAlaFxO29etwDJZgXHlRi7tshcX60OQylO6bCbvFczUMhn0C4yCsnks/apdEusPbXk/ihZsJykv61CJiNLEAI7MctsUvGpyPUKSXS1zJMrE0lR7/upsVE9vP5obBEeOaw4M2Kp5Ze/aWluGO03WOnm+ou8OjGsYuZn5qK3dQm4mb3IyGJTNq5fSr6SCItOblfP9yKe8rEMlIkqTqMti/6x1dHToli1bsh4G1eLm6R4ZtcneJZFRMna2MDhmrzVbN144Y9TEK8ptnfdxm9DN7toYGHQl8RqiGlraioZQbVEEWNrjewuTr9nrsSrbFXg1U6nluWyV5PseZl1llGuf70c+gzi31xS2MoCIKO9EZKuqdlQfZwaOzKplL7e8lS5GzTIGiFLWF7UE0C/rUEs2yisYTHJdz7stR2Nc70vBNwxRdmuyKUktG4j73c9mXu97kuuT4m5WXn3tF+n98FLE9WLV10GlHPuNA/0AiptJJSLywwCOzLJpTVtS3DpnhizhcxMlkIoadPlN6KKWJgWVoCW1rmfcOcswcP8X0DT47vAxRVVr3JBltyYDzbAbiLvdL09MfwkQRZzNysM21snb++GnqOvFnNfB7K6N6OntH/F7k0Fq0UpQiaiYAjfyJookyqbgeVVLltFH9QRyfsMmbBpzNZ4be0mpJHXHas/bBh33m9BF3TDYLxhM1MyFaLrg2yM2j5eOP6t5M/kFs9rwaOeZkTf1rhZ2A3GnKNm+Ndv2YHbXRkzrXIfZXRuNbHpey3MFfQngJomgyNS17xTU4Cet829KPWzonmSQWvmyYk95L8vKlxV5eO+JqL4wgCOzZi4sTaZrnFynasfqUoC0tHVUoOTLK5soDdEfCyMDgfkNm9DVvBLtDXtL674q5Znlx4sadPlN6BbMasONF85AW2sLBKW1QH5rZTL9dn/mwtIayqU9pT/P+8bInzO4vqrPX+OozioljSKhzq9TmhPJoOeK+iVAc4PgQN+A8cDH1LUf5v1wOyeLf/gEZi3bYHVAF/Uc5VGSQWpmX1IREUXEEkoyLw9r2uKsY3PrnAkAOhj9sTCyrG/JgdXD7fKHOcozo5YABq35ilL2aFM3uOoyp28e9yxOeu7bqTfCCbOBeC0NJNJcyxT0XH7ve5rrk0xd+2HeD7dz0j+kNb+utMry6mGPOZPrWKsVtQSViIqHXSgpeTZ2maylW6aT8zVJw8HgrZbHclraCrh2XAzusOjF1OTRlg531eOY37AJf9e8Ei3OwLe5JZPMb+C5DvlZmNa5zusqwAtd5xodc9BzRekCGNSZM+2AotZr3+ucVAvTwdKWz02RJBUQm+xSS0RkArtQUjYMd2w0Ju46NmeWcWmrx2PtKv3ObaLuNZFPoAmMqeYitny7X50dWdK0emTwBsRqKhOH77mO8FlIM9sZ9FxRsmxBnTnT7hhY67UftkFNmMxMETtDZi2phklJZveIiEziGjhKll/Hxix5BUS1BEq+9xm9jm14Iv/mrtG/t7wJjKkGIHFUT5onyV73G9bYVCYxET4Ltq0tc77vhx7ShP5B93b+YQLMPKwpCtugJszrzVNZXh4bt5gUdV0wEVFWmIGjZBnu2GiM2zq2WgMlrzVxTs6MkN9EvlJyaVvJaQrClkVVZ0e6dQLa3YI427auiPBZsHltmV9AcvMnTgjcfNvvMWzhdf6dgWvYzEyYbKoNreuDtgmpF0ll94iITGIAR8mydV+4SkBkIlCqfiyv1TOViXrQRD4PTWAMizJ5rC5zumlgofsaOEuylsM8PgsvYwI+0rlu1MQ97t5XUYICU81swmy+Xbmt7arPSa1BVlBZni2BE0s9iYjygwEcxefXmMFkpss0k4GS87E8G6S0H/zTxqA2Q1Emj9VBwtYjzsJTx03NpAtlFJv/4AuYvvXLIwLN/9ZGjEEvnjvkYnQfmIBv3ncRgM+Nes1Ry/CSDAqidDb1auCRxzVFtWZmgjKctgROeSr1JCKqdwzgKJ6gxgwmM11pq7V7ZlDQmnZQa2MX0CpRJ4+jJ9NnArjS/MAMuuaXx+BD/VdgSdNqTJJ9eEMPxeHyLt4j+wEA7bIXy3QFblrXhAWzvjrivlGbmngFBV9c/QSuXbU9VplelJJLWxrfZM0v+LMlcLJpm5A8saH8lYjqDwM4isdvPVclSEizJNBUsBKne2ZQ0JpmUGtrF9Aq9TB57O7pxR6chrV9pwEANo25GkeVg7eKcdKHK/ruADAygIvaHS/pbpBRslFcU+TPlmufHRijs6X8lYjqDwM4isemJiUmg5UwgamfoKA1raA27utIyeK5x2LTfbfiGtyNSbIX3ToB38RFOG3u58w/WUYZyeqJulf3zEkN+0Ydi5rJCtMGn+ub7GBL4MRsaTjOjJvbGs/e/kFcs2o7lq/fyfNHRIlhAEfx2LSey2SwYlNgGsQvIMnJ61jQ+CjOa16JpsF3AZTKCbsaV6Kp8XgABoOrDDOS1RN1r+6Z77YcjXEu94+SyXILCtxwfVP2bAqcmC31V51xc2vQU8FsHBEliQEcxWNTkxKTwYpNgamfoIDE5tfhDDylAU06MthoGnzXfKYww4xk9UR95ZhL8aXBf8QY/e/h2ww0jsW4c+LvkRi3GyTX9aSLgVM+uK0t9cMsNxElhQEcxWNTkxKTwYrpwDSpsr2ggMSmANupOvBUj0mR6UyhgSA/TnAzcqJ+LrDjD0dcF00GPzu1doNMfV1PDprs2IzBdnpqyVgzy01ESQgM4ETkdgDnAXhVVae7/H4xgEscj/dBABNV9XUReRHA2wAGAQyoaoepgZNFklzPFWVyZzJYMRmYJlm2F2ZPOcC+CbJb4OnGVKawch157dEX8nmMBzcprYWMUqaXdFt7Z8Bx+WG/wJf1tuHSWVub7NiKTTTS5bW2tNEjw125DxGRaaI+NdwAICIfBbAfwPfdAriq254P4FpVPbP884sAOlTVfbW+h46ODt2yZUuUu1ARVQc+QCkgO/8W78mdjd/me+4LNxm49il7HztJS1vhGUxVBL3XYbldRzU+z+yuja4TuLbWFjzaeaad119E0zrXjXpn5jdswpKm1Whv2BfrdVUHHJvGXI32Bpd/Hmy/fi0ReD2SUV6Z7BsvnAEAnr9jME1EtRKRrW4JsMAMnKo+IiJTQz7PJwHcFW1oRB5qWa+U5pYFYSXZSMTWEskgXuWu0gjoUPJlpsPjmBzpeXz37MrJlg1BqrMM8xs2oat5JcZVNiCP8bqqs3tenThta7JjK1v2kDMhD6WgYTLZtr8GIioGY2vgRGQcgHkArnIcVgAbREQBfEdVV/jcfxGARQAwZcoUU8OiPMtJB8VASTYSsbVEMohX4Gki41bN83qRyFket+BmSdPqUuv/+xpGr+WzcMuGINUdLJc0rT4YvFXU+LqqAwuvTpzGS2dT/mykFYzYsodcXHkqBfVrOMNmNESUlgaDj3U+gEdV9XXHsdmqeiKAcwB8vlyO6UpVV6hqh6p2TJw40eCwKLe8JnE2dFCMYs4NpeDEyWSWbObCUiCytKf0Zx6ChZkLS8Ha+MkApPRnEsEbYPQ6Wjz3WLQ0NwI4mJlqb9iLBmh6jVgStmBWG268cAbaWlsgcN+XDkBNr6s6sLhpYCEO6JiRNzL12ahkRN/cBUAPZg53rI7/2D4qwcienl4oDgYja7btMf5czuuxIo+bb3utu/zi6icwrXMdZndtjHT+1mzbg9ldG2u6LxGFw89Ztkx2obwIVeWTqtpd/vNVEbkPwMkAHjH4nFRktnWCrPX+aWfJ8rIOK61yV4PXkbOEaskBl8yUm7x94YCqTMLN5jLI1dm9tUOnYYw2YNm4H2Fc78vpdmg1KMzmzkm0kw9T0peH0kSvks/KeYySkctTNo8or/g5y56RAE5ExgP4IwCXOo4dCqBBVd8u///ZAOJvcET1w6ZOkHHvbzJY8QvQCrIOyyjDAfRwcLPUIzPllIf1iEESCoArAcVpcz+HcbP+1tRoDwoowTYV2ITd3DmpdWl+ZXumJ1lJBYNepaBOYYPgpLuoEsWVhy9VgvBzlr0wXSjvAnA6gAkAXgHwFQDNAKCqt5Vv82kA81T1Isf9fh/AfeUfmwD8QFVD/SvNLpRkXNxujbZ0ewzqzGnLON3kJTMYlte5TqIRS9YSfO/iTGZ87+vzWVhz+vrYHQMrzx0UeFRk0RnSZJdKvw6McSdsbo/tRgC80HWu723cuqg672/ThLkIE3nTin5OkvwcpcnrcxbmM0rRxOlC+ckQt/kugO9WHXsewPHhh0iUoLgNUWxpqBJUFpblOOstM5hmI5asJVTuGidDFHhfn8zh8gfjfXscNuCoyGpdmskulUl+416dmXUrQwXCNWfxy+Y51yQ6nzcLLEEbrR7OSVEyV0VpoJRnJpuYECVvx+rSN+tLW0t/hm1IELeRhS0NVYICtKjjjHo+vW4f1DDCL/DMqzQbsRSU32Qm9n193p+4gY3bc1drFIGglO3K6tt1r8lULZOspLcsWDCrDY92nokXus7F1xceX3NzFrfGLtXCXmNJinPtF1U9nJOibP1RlAZKeWayiQlRsuJkceKu47Flv7WgLQmCxunMkrUcCfTtBwZD7u/ld/5tzgyaVrRS0AzFmcyEuq9H5tDr2+MGEUzrXBdYuhU0viRLoqKUmFU3jamMrZZJVtxv3KOMO0xzFi/V9/Uqpww7YU6qpC/uRD7uuGwsVSxKcOOnKJmrOJ9RMoMBHOVHnK5ycRtZ2LLfWlCA5jfO6gCs93WM4nc+/c5/mMxgUnvhpamIpaAZijOZiXNft8AGCN/10K9Mry3BiUzUErOgSVZawWAtpXFx9lRz3tdrHWCY6yTJkr4412/ccdlaqmg6uLExSDX5pUotTJ4T7nuYrcAmJllgExNytbQV8Fo2u7Qn7dFkp9YMkFdTh1E8zqff+fcM0MrNU4Kar+SFzU1icijOgv64zQCCWv8D3s0+smpEkHVTklonfybHHVWc9yrJcSc9Lr/3yvTrSqqjK1D758rmZiFZBZY2nxPyVnMTEyJrFCWLE1etDSXCliv6raPzOv9xMoN5UqRSUAuYLJWb1NqCMz4wEcvX78S1q7aHKtOr/G5a5zrX23iVbmVVPpR1U5Jav3HPsjQuznuV5LiTGNeenl5M61yH8S3NeKdvAP2D7hllv/vP7toYuROsqWyeyc+Vzc1Csspc2XxOKDoGcJQftqxDyyuvAMzJ73z6nf8wAVpaG3cnKeqXCCbXyxV07Z2pUrk4E8laSreymISZLDFLM6jKet1Pre9V0uM2PS6gVCPR09s/6rhzou53/6gBmOmgwNTnKur1bWO5pWn1sMawnrALJeUHu/7FM+eGUsDl1NAMtLwHoc5n0PmfubBURri0p/RnEd8Xt3PoFfQGdeaMwuRjhX2+Wrq9ZihOB7u8dFQzOU6THSqD5OX8VrN13GE6bbqpTNSD7t/bP4gvrn4C0zrXYXbXRqzZtifwMcMeT0uU67vy5c+ectObShDr97rzKM3PPCWPGTjKlyJkcbJioozRef4rGaF7FxUqI+QryjmM03QnyccKktNGLXEmknnpqGZynGk2U8jL+a1m67jDdtqsVpmoO+/vlYmL29DHKyhIK9MV5fqul9LCrBuokFlsYkJE3rzK9orSlARIrjTRZNOdNBv45LRRS5aNMvIqaDIdZbJdDyVocSV1jryufSevZhVh7guYaeiTdhONsOd7Wuc6r79d8ULXucbHlSV+TvPHq4kJAzgicucXpP1kWS4n+aOECURNd/2s5RylGVTltNsrO6yZFeZ8ViaDe3p6IRh51fDcj5Tk9en22M0NgsPGNqHnQL/vRN3tvl4EiBXoewWLjSIYUs0soMj6yx8GVcHq+RyxCyURRRNn37e8CCpNzHLz+KQeK0hOu73aWu4Wl+mJS9jHCyorq574V4f8RSxBiyPJMj2T3Vy9ttQAMGJ9mPO+YRuPeJUzhy3XTEqWpYW27slnE54jdwzgiMidX5CW00n+KEGBaJabxyf1WG6cWcaWI4HGMcBg38Hf56Tba9E2ljU9cYnyeEFrCt0CEq/b2iaLb/OTbvaRVDdXN36Bp9+59et+Gfex48jyy596WX8XR9xzVNTsHQM4InIXZ9+3vAgKRONmGk023UmqgU91lrH39YPdSXvfSL1BTVH/sa2F6cldlMcLak4RJvCwsbtdVt/mZ72VQlhhG6S4vf9B59Yt02XqsePK6ssfW7t42iToHPn9m1Hk7B23ESAid34t84uypUPQtgB+m5oXhVuWcagfGHNo6ltC1Es777BMT+6iPF5QC/2gwMPW7nZeQew1q7YHtsyPw9YtCdwsmNWGRzvPxAtd56ItQuv5oK08Fsxqw40XzkBbawsEpbVvcR877HYHtorb2n/Ntj2Y3bUx1+cgiN85Cvo3I872MrZjAEdE7uLu+5aHvcSCXmOUfd/yyqL1jEX+x7YWoSZ3ET5nUSaL1ZPtttaWEQ033AKSynS8+rY28Qt+k/zCIOh8unFOzk/46gbMWrYh9Ym62/vc3CA40DcwaixhviBwBodfX3h86KDWb/1cnr/siRPY18sXXn7nKOjfjCJnOFlCSUTeai3by9NeYn6vMem1Z2ny6qZp0XrGIv9jW4vA5goRP2dRmzX4lZXZ1DQmStlt0Dosk+uP3MYVtqthdelXT2//8O/SLAOrfp/HtzTjnb4BvHGgf9RYopaJRrmG4q6fs1Wcz1G9rJ/zO0fXrtruep/Kvxl5KV2uBbcRICLzcrqXWKFUNybp2z+6Mcn5t5T+35I9/bJu520j3+Ckhs9Z0dYYRm3PH6ZJh4n9v+JuGxBmf7YsPhd+n1GvLwiS2irBTVZ7t2XxuQqzf13RPu/Vgv7NKML2MtxGgIjSY1FZXl1ya0xSrdJNszLRrzXLaHAj9FTbeSe1gbthvs0VavicFa1TZ9QshPPb/D09vZjfsAlLmlZjkuxFt07ATQMLsfWIs1IfV7UwWecsMtN+WfIks7JhtzvIIrPi1ijj2lXbcc2q7cOBbRKfuaDsUpEbeFQE/Zvhdk2e8YGJWL5+J65dtT3XQS0DOCIyz6KyvLrk1pjETWWin2SpbIRAKfGyvOGx7AKcW0/bXOLrh5+zmspuK0Hs5rXfwfStK9Eipcx0u+zF3zWvxFPHTQUQL7MVtxw4TMlgFsFKUNCQ5BcEQdsdZNUUxi1Yr4SWSQZNQcFLliWWaWX+wvyb4Xfd5DmoZQBHROZlvc1AnOyKLZmZqONw3t6z+XeVuBP9BDZCT2wCWD2W6nMUdn8/m2T9ObNAnDUuJz33bUD6Rhxrkb7ScVyZ2bgA98m5U1bBSpabXjvZtAYzKChPKmgKOgdhvkRIItBKO0iK8m9GkdYNMoAjIvOybP4Rp4GKLc1Xoo5jVHASgomJfpIboZsWJiuZtxLfIjXZqVGsgCLBUu+4gY5b8xARoOdAf6bBik2Bky3lwGGypUmVu/qdg1pKLE2UftocJBWpUVZgACcitwM4D8Crqjrd5fenA7gfwAvlQ/eq6rLy7+YB+BaARgArVbXL0LiJyHZJbTwdJE7QYEvAEXUcYYKThmbgkMPNbs7tVcInDaW29l6ZwCwCpTDPmcfSw6w+Z5aIFVAkWIJqItCxJUCpZuu4ojKVfQqzQXkW5a61lFiaKP20OUjyCmobRDCtc12u1sSFycB9F8DfA/i+z23+U1XPcx4QkUYA/wDgLAC7AWwWkbWq+ssax0pEFCzOt+q2NF8JM47QJZOSXGbGrYQPANS/U5zvBDmpElavyXpFnZUeFknNAUXCJaiB47KlXLsOmSzzq26M41hdCyC7ctdaSywras2a2dy63yvYrjTEydOauMAATlUfEZGpNTz2yQB+o6rPA4CI3A3gAgAM4IgoOXG+VbelKUTQOMKWTCa9bUN1CZ80BAdvfhPkJEtYXYPN8lRr/OR4k+c46xU5cc9OXku9KTbTZX7VjTKSKjGN+ti1lFg61bJeLul1knHOb5hupraUewYxtQbuIyLyBIBuAP9HVZ8G0AbAOQPZDeAUrwcQkUUAFgHAlClTDA2LiOpOnG/VbWkKETSOMCWTaY3bWcK3tNXnhiEygUmWsCY1WY+7XpET92xZVur98r1fwkd+cGiuSrnyKMkyv6RKTE03B4lS+hnluZNcJxlmHEEBnvP9mda5zvV5bCj3DGIigHscwO+p6n4R+RiANQCOQemrzWqedT6qugLACqC0kbeBcRFRPYozUbelKUTQOHxLOhMsmazwyiB5Zg5DZgKTLmFNYrJuYr1iHjtgUjwe1/R7dS8U+SrlyiOby/y8ApAksoZAuNLPWvZbTOK6DRpH1CDX5usgSOwATlXfcvz/gyJyq4hMQCnjNtlx03aUMnREZKuilHbFmajb0hTCbxxxA6U4/DJIcTOYtpSwRhE16LRlnSVly+Na79ajhv8/L6VceWTLdgjV/AKQJLKGYUs/bWlMEjSOqIGmrddBGLEDOBE5GsArqqoicjKABgD7APQAOEZEpgHYA+AiABfHfT4iSghLu/IjbqAUJ1D3yyBVgsdaH9uWEtYoogadeQxSi8aGL6pcrvUDOgY3DYwch6kJclobK5uW1Lht2g7ByS8ASTpbFGdLgrQEjSNqoGnrdRBGmG0E7gJwOoAJIrIbwFcANAOAqt4G4OMAPisiAwB6AVykqgpgQESuArAepW0Ebi+vjSMiG7G0Kz/ilHrGDdSDMkhxs59AvjZhjxp05jFILRJbvqiqutZfxgT83/4/wdqh00bczMQEOe2NlU1JetxRyvzSCoD9ApCbP3FCZtkiWzJVQeOoJdDM67YYYbpQfjLg93+P0jYDbr97EMCDtQ2NiFLF0q58qTVQihuoJ51BqvV1ZTUxjxp02rLOsl7Z9EWV41r/2bY9eOjeJ4Eh8xNkmzdW9mPLuNMMgP0CkCyzRbZkqoLGYUugmQZTXSiJKO9Y2lUf4gbqtmaQTE/Mg7J5cbJ9tqyzjMvnHFhbsmfpF1VJTpBtWb8UlS3jTjOQDApAsswWxXnuqH8f+N3ebxy2BJppYABHRCW2TszJrLiBuq0ZJJMT86Bsni1leKZFCUp9zsGawdmxW30nxuIvqpKanNuyfikq0+Ou9ZpLM5AsYgASNYMZN+OZ15LIqBjAEVGJTRNzG5oMFJWJQN3GDJLJiXlQNs+mMrw4nJ+zliOBvv3AYF/pd0FBqc85WP7ftxht9W1UHX5RldeyMpPjjnPNpR0Ap5npSkPUDKYtpbO2a8h6AERkkZkLS50El/aU/swqeHvg6vJkXA9OJHesTn8sRTRzIXD+LaUtByClP8+/Jb33esdq4ObppU2/b55u7n2dc0NpIu5U68Q8KJtnaRleJNWfs97XDwZvFZWg1I3POYjT6jtxWV//GVgwqw03XjgDba0tEABtrS248cIZ1k+GTY47zjW3eO6xaGluHHHMxgC4EqTu6ekdsZfgmm17Mh1X1AymLaWztmMGjojsUpTshs2yyqAlWXpoMoMclM0zXYaXRcbZ7XPmxitQ8zkHk8YGt/qe37AJS5pWY5LsRbdOwE0DC/FAz2mj7pMIGzPICYuU1bGoAsJUp8g4QUFeyhptzVxFzWDmteQ3bQzgiMguRchukLukg3NTE/OgMruoZXh+E+Ks1tOF/Tx5BaU+52DxoH/p2+WH/QJL+ldinJQyfu2yF13NK/Ge5jEAzq3l1ZCpoCun6zuDSiTjBgVZrqsKWxZpa+YqailsXkt+08YSSiKyi98GyJRveQnOg8rsopThBZUE+wW1SQrzefILSn3OQVDp25LmVcPBW8U46cOS5lXxXlO9Mll2ntX1GFNQiWReyiCrRSmL9Mto1frcs7s2YlrnOszu2lhzKWbUUti8lvymTUp7btulo6NDt2zZkvUwiCgL1d8AA6WJZMHXqdSFm6d7lN1NLq25LKKg17y0FYDbv8NSWouaFLfPWUMzcMjhQO8b5rdOcMrqNactrVJEk58rw+9NWk01pnWu8xo1Xug6N9WxmDS7a6Nr5rCttQWPdp454lh1FhIoBam1BD8mH4viEZGtqtpRfZwllERkF5u6YZJZddgBMDDrmFVb+6ifM5OldVFfc9RAyIY1XGmWIprMbBu8Hm3ZALsij+3lo5RFmlyrZ+t6OjqIARwR2acOmwwAsGPimaR6DM6DJsRZBrVRPmcm1y9Gec1RAyFb1nCl2YzJ5JcABq9HmzbAzquoa/dMBam2rqejg7gGjojIBvWyfUKcrSqS2oIgyccO2t4gL23tTWZ5orzmqGuybFnDleZ6T5NbaBi8HmsKAmr8HJpeN2Vq/VdcWa3dM72eLogt5ztPmIEjIrIBt0/wl2RmJevtDdLMONea5TVd6hn2NUcNhGxplJNmaazpzLah6zFy58eYn0NT2acwpZ9prafLaguDNDOaaZbaFgmbmBAR2aBeGjvUKskGKGEeuwjlrXEaBGXVXCjq+25Lo5xazlcRrjGHyI0w/JU1mgAAIABJREFULHnvghqH1EuDjySDVOdjN4hg0CUWcWvUUo/YxISIyGZZNbOwmXNC6xrcwkxmJShrY8u6qlo4z6E0ADpyTVLoLG9Qliep4CPMmiznc7ccCTSOAQb7vG+fhiybxFgicvbIkuxpUOlnvTT4iJrRDBvwVQfAbsEbwPV2QRjAERHZoB47NPpxy2C4MRHgBgXPNpW3RgmUqs9hdfBWEXaC7FVal2UJavVz975e2g6h5T3e2yGkJasmMRaJFARY8iVWUOlnYRt8xPgSJkoZpFsA7Cap9XZFwSYmREQ2yEszi7S4TWirmQpwg5pAWJIZiNzoJsw5BOJPkE00DvFrXuHX+MbtuYf6gTGH1tYoJ444jXBsucayZLIZSwxBjUPSbvCRiphNtII2UncKE+gWoYNo0hjAERHZIk6HxqLxnbgaDnCDgmevACft8taogVKYyb+JCXLc4CPO5NGWwCduF1lbrrEsWfIlVlBHy6w6QyYq5pcwUbKSXoFuo4iRDqL1giWURERkH89yqoQaGviVu9lS3ho1WPE6h9II6JC58sK4pW9xygeTLrsLW1YWtwTSlmssa5bsAepX+plVZ8hExfwiJErHUa8OlwzaomEGjoiI7GNJORUAazIDkbM0Xufwj28zm+WN+17FmTyGee5aSxujZNXiZgJtucYolAWz2vBo55l4oetcPNp5Zv4Dj5gZ4ChZSdN79tUrZuCIiMg+pve2MjGerCfTUbM0cc9h2OxT3OeJk0WL2uQkSoOVKFk1E5nAKNdYwbYcoIzFzABHzUqa2rOvngXuAycitwM4D8Crqjrd5feXALiu/ON+AJ9V1SfKv3sRwNsABgEMuO1j4Ib7wBERUW4lOblOa+Ke5r5vST5XnL3FouzNWJTzRcaltel3bEX5UqAor6PMax+4MAHcR1EKzL7vEcCdCuAZVX1DRM4BsFRVTyn/7kUAHaq6N8pgGcAREVEuFWVybXpT5aBJVVKTrihBWLWo5yCtiWMt70312I45G3h2Q/aT3LxMtmscZ71s+m2Novz961BzAFe+81QAP3YL4KpudySAp1S1rfzzi2AAR0RE9cJ04JOVOIFPtSwnVXHeD1sng1Hfm1B7KkrpMcdPjhdExdmnELDj/FaLMc7ZXRtdm3u0tbbg0c4zTY+UivL3r4NXAGe6icmfAfhXx88KYIOIbBWRRYafi4iI6lmcfbeSYqKtvQ2vy2RbexP7xNUqToOVrBuLeF0HUd+bUPsBlgPCqNsfVI837j6FaV0XUcQYZ2E3/baVLduKpMBYACciZ6AUwF3nODxbVU8EcA6Az5fLMb3uv0hEtojIltdee83UsIiIqIji7ruVlLiBjy2vy2QX0CwnVXGDsKz2ZvS7DqK+N1HPc61BlKl9Cm2bbMcYZyE3/a6w4YumanW0n6KRAE5EZgJYCeACVd1XOa6q3eU/XwVwH4CTvR5DVVeoaoeqdkycONHEsIiIqKhs/fY+buBjy+symX3KelKVVRAWR1AHzCjvTS3nuZYgqpZ9CqMcz0qMcRZy02/Ani+aqtm0/UzCYgdwIjIFwL0ALlPVXzuOHyoih1f+H8DZAPJZgEpERHax9dv7uIGPTa/LVOBTR5MqY4Kugyjvjdv5D1JLEGVqn0LbrosY4yzsnme2fNFULeuy5xQF7gMnIncBOB3ABBHZDeArAJoBQFVvA3ADgKMA3CoiwMHtAt4H4L7ysSYAP1DVf0vgNRARUb0xse9WUuLsGWfz64qiupnF8RdH63qYl+6ESTF5HbjtlTfchXIXhhuYVNQaRKW9T2FaYo6zkHue2fRFUzUb9uxMQagulGljF0oiIvKVlw52Ubl2DDTUITAtcd+bor63UaS9r5ypIKreA283RTwnBez2aKtY2wikjQEcEREFKuLECHC8Lo/siO2BTNzJHSeHJUW9vm2U1LmuJRDPw/vOL1lSwwCOiIgoT/IayMTdQ87kHnRR5WHyTGYlGYzUshm8ybEkeT3zs5IKrwAucA0cERERZcDmdSZ+4q7fymodYPXkudJZD+DENI/CBhhBHT/j8PwM7yp9UVE9LpNjSfp6rpO1ZrYyvZE3ERERmVBL+3Ib9maK210wq+6ESXfWs+G9qRdR2twn+UWJ75cOLuMyORZbO0WSEQzgiIiIbBQ1kLFlbyYTm2dn0Qo8yYm8Le9NvQgTvFQCatdyXZjJ+IbZwsE5LpN74+U1g0+hsISSiIjIRlHblydZChZV3PKqLMqzwpRu1rruJ+57w/VG0QQFL67dXh1MZXyrP8NewWKlpLLlSKBxDDDYF38sRdmShFwxgCMiIrJVlECG37jHE7SPWZw1RXHeG67Niy4oeHELqIdvY3i7Dudn2KupCQBAgd7XgYZmoOU9QO8b8YL1qPvyUa6whJKIiKgITJZf1aOg0s04a4rivDdcyxRdUPmxZ+Aspe6QSQXGYUoqh/qBMYeWOq7GGUtWpciUCmbgiIiIioDfuMfnl/GMk0WL894UKbOaViloUPlxVuWFoUsqDb237BRZWAzgiIiIiiDqmrm8ymo9WJxJf5z3pihrmWopBY3zXvsFL1l+2RGmpDJv722auB4UADfyJiIiorxIctNlW587y9dsUtabWrs9ftaBQNbvrQ3nIIqsz1cGvDbyZgBHRERE+RA1CDAtqwlv3ibabpa2wr1kUErrvapl/V6nJctrKm/BUL1cEw5eARxLKImIiCgfsl4PltWaoryuZXIGJ9IA6ODo23iVC2b9Xqclq/fWpm1HwqqXayIEdqEkIiKifGCnzfyo3rzcLXjzW3cW9F5XNuJe2lr6k5uiR5PHYIif/2EM4IiIiCgfgtrDkz289lqTRoRqa+/3XlcHh5WGKAziwstjMMTP/zAGcERERJQP3NsqP7wyOToUbo8zv/c6673x0sz+JfVcpoOhNM4JP//DuAaOiIiI8iOv68GKyqsJh4ntD7ze6yzL/2rZDsHG5zK57Uia54SffwDsQklEREREtfDrZAgk1+Uwy26EXs8tjaXsoslOknnpupiXceaQVxdKllASERERUXRBnQyTKnfLci2UZ2noIIyvx8tLo5G8jLNAWEJJRERERNEFTdyTKnczWf4XlVdpqJOpdvwmylDTkJdxFggzcEREREQUXZadDGcuLJXnhWmIYpJb9s+NiexTXhqNsDtk6kIFcCJyu4i8KiKuhaxScouI/EZEdojIiY7fXS4iz5b/u9zUwImIiIgoQ/U4ca8uDZVG99uZCGJNlqEmufUCu0OmLlQTExH5KID9AL6vqtNdfv8xAF8A8DEApwD4lqqeIiLvAbAFQAcABbAVwIdU9Q2/52MTEyIiIiILeHWZDPv7ovNr5GLTeUiz0Yjpa6KOrzGvJiah1sCp6iMiMtXnJhegFNwpgJ+JSKuIvB/A6QAeUtXXy4N4CMA8AHdFGz4RERERpSpMe/h6b+ue5Xq8KNJqNGJ6S4E0tyjIEVNr4NoAOMP63eVjXsdHEZFFIrJFRLa89tprhoZFRERElJA0N3TOQtYbZpuU5HuV1Xq8KNJar2j6minSNWiQqQBOXI6pz/HRB1VXqGqHqnZMnDjR0LCIiIiIEpDkmiJbFKU9fD28V0HSWq9o+pqJ+3gF/ZLFVAC3G8Bkx8/tALp9jhMRERHlVz1kBrLsMmlSPbxXQdJqNGL6monzeAUO3E0FcGsBfKrcjfLDAN5U1ZcArAdwtogcKSJHAji7fIyIiIgov4qSnfJTlC6T9fBehZFGqWeYayZKVizONVjgwD1UExMRuQulhiQTRGQ3gK8AaAYAVb0NwIModaD8DYADAP60/LvXReRrADaXH2pZpaEJERERUW7ZvHmxqa59eWnQEcTm96pogq6ZqE1J4lyDBQ7cQ20jkDZuI0BERERWs7V9vK3jyhLPSXymvhRIczuDNJ8rIV7bCJgqoSQiIiKqH7ZuXlzgsrGaRX2vCtr4omYm15KlmRUrSgmwi1AllERERERUxcY90IpaNhY3AxT2veK+Y6P5fSkQ9ZykWc4apvwyp5uEM4AjIiIiKooirvdKM6gyGawUhckvBebc4F7OmlRWzC9wz3GwzhJKIiIioqIoYtlYmmWh3HdsNJNbA9hUepzjcmMGcERERERFkfQEOYsAJc2y0DzvO5bUe2P6S4Hq7QyAbILeHJcbs4SSiIiIqEiSWpuXVclZmmWhcUr8siy/TPK9SXI7iSzLGHNcbswMHBEREREFy6rkLM2y0DgZzCwzOkm/N0ltAp5lGWOOy42ZgSMiIiKiYFkFKGlvKF5rBjPLjE5eywGzHHeON6pnAEdEREREwbIMUGzcsqFa2h0WnWwuB/Rr1Z/1uPNwXblgCSURERERBctxyVkqsuywaPq9MdUQJaixC6+pmoiqZj2GUTo6OnTLli1ZD4OIiIiInHK68XEhBJ17U+9NdWMRoBRU1RKM3jzdI8M2+WAHSl5TnkRkq6p2jDrOAI6IiIiIyGImg6ogYYKusJa2AnCLNaTUEIV8eQVwLKEkIiIiIrJZnjYzdzK5CTgNYwBHRERERGSzvGxmXi3pNW5ZbCxvAQZwRERERJRvRZ/Ip5nJMhl0JdnYJahBSoFxGwEiIiIiyq/q9WGViTxQnGYYaW5RYHp/tKRa9fuVlRblfffAAI6IiIiI8qseJvJ52cw8TXndvNwABnBERERElF/1MpHPQ1BlQthtBbLeBDxDXANHRERERPnFTofFEWVdWx1vAs4AjoiIiIjyq14n8kVs3BJlu4QkG6RYjiWURERERJRfaa8Ps0FRG7dELYetl7LSKqECOBGZB+BbABoBrFTVrqrf3wzgjPKP4wC8V1Vby78bBPBk+Xe/U9X5JgZORERERASg/ibyRW3cUsfr2qIIDOBEpBHAPwA4C8BuAJtFZK2q/rJyG1W91nH7LwCY5XiIXlU9wdyQiYiIiIjqWFEbt6S5XUKOhVkDdzKA36jq86raB+BuABf43P6TAO4yMTgiIiIiIqpS1MYtdbyuLYowJZRtAJy5zN0ATnG7oYj8HoBpADY6Do8VkS0ABgB0qeoaj/suArAIAKZMmRJiWEREREREdajImap6K4etQZgMnLgcU4/bXgTgHlUddByboqodAC4G8E0R+QO3O6rqClXtUNWOiRMnhhgWEREREVEdYqaqNgXp3BkmA7cbwGTHz+0Auj1uexGAzzsPqGp3+c/nReTfUVof91zkkRIRERERUQkzVdEUqHNnmAzcZgDHiMg0ERmDUpC2tvpGInIsgCMBPOY4dqSIHFL+/wkAZgP4ZfV9iYiIiIiIEhNljznLBWbgVHVARK4CsB6lbQRuV9WnRWQZgC2qWgnmPgngblV1lld+EMB3RGQIpWCxy9m9koiIiIiIKHEF6twZah84VX0QwINVx26o+nmpy/3+C8CMGOMjIiIiIiKKp0B7zIUpoSQiIiIiIsqvOTeUOnU65bRzJwM4IiIiIiIqtgJ17gxVQklERERERJRrBencyQwcERERERFRTjCAIyIiIiIiygkGcERERERERDnBAI6IiIiIiCgnGMARERERERHlBAM4IiIiIiKinBBVzXoMo4jIawB+m/U4XEwAsDfrQdQpnvts8fxnh+c+Wzz/2eL5zw7PfbZ4/rNj07n/PVWdWH3QygDOViKyRVU7sh5HPeK5zxbPf3Z47rPF858tnv/s8Nxni+c/O3k49yyhJCIiIiIiygkGcERERERERDnBAC6aFVkPoI7x3GeL5z87PPfZ4vnPFs9/dnjus8Xznx3rzz3XwBEREREREeUEM3BEREREREQ5wQCOiIiIiIgoJxjAhSAi80Rkp4j8RkQ6sx5P0YnIZBH5qYg8IyJPi8hflI8vFZE9IrK9/N/Hsh5rEYnIiyLyZPkcbykfe4+IPCQiz5b/PDLrcRaRiBzruL63i8hbInINr/3kiMjtIvKqiDzlOOZ6vUvJLeV/C3aIyInZjTz/PM79chH5Vfn83icireXjU0Wk1/EZuC27kReDx/n3/LtGRK4vX/s7RWRuNqMuBo9zv8px3l8Uke3l47z2DfOZZ+bm736ugQsgIo0Afg3gLAC7AWwG8ElV/WWmAyswEXk/gPer6uMicjiArQAWAFgIYL+q/r9MB1hwIvIigA5V3es4dhOA11W1q/wlxpGqel1WY6wH5b979gA4BcCfgtd+IkTkowD2A/i+qk4vH3O93suT2S8A+BhK78u3VPWUrMaedx7n/mwAG1V1QET+DgDK534qgB9XbkfxeZz/pXD5u0ZEjgNwF4CTAUwC8DCA/6mqg6kOuiDczn3V778O4E1VXcZr3zyfeeankZO/+5mBC3YygN+o6vOq2gfgbgAXZDymQlPVl1T18fL/vw3gGQBt2Y6q7l0A4Hvl//8eSn/RUbLmAHhOVX+b9UCKTFUfAfB61WGv6/0ClCZcqqo/A9BanghQDdzOvapuUNWB8o8/A9Ce+sDqhMe17+UCAHer6n+r6gsAfoPS/Ihq4HfuRURQ+sL6rlQHVUd85pm5+bufAVywNgC7HD/vBoOJ1JS/eZoF4OflQ1eV09e3s4wvMQpgg4hsFZFF5WPvU9WXgNJffADem9no6sdFGPkPOK/99Hhd7/z3IF2fAfCvjp+nicg2EfkPEflfWQ2qDrj9XcNrPz3/C8Arqvqs4xiv/YRUzTNz83c/A7hg4nKMdacpEJHDAPwIwDWq+haAfwTwBwBOAPASgK9nOLwim62qJwI4B8Dny6UelCIRGQNgPoAflg/x2rcD/z1IiYj8FYABAHeWD70EYIqqzgLwlwB+ICJHZDW+AvP6u4bXfno+iZFf3vHaT4jLPNPzpi7HMr3+GcAF2w1gsuPndgDdGY2lbohIM0ofqjtV9V4AUNVXVHVQVYcA/BNYvpEIVe0u//kqgPtQOs+vVMoFyn++mt0I68I5AB5X1VcAXvsZ8Lre+e9BCkTkcgDnAbhEywv1y6V7+8r/vxXAcwD+Z3ajLCafv2t47adARJoAXAhgVeUYr/1kuM0zkaO/+xnABdsM4BgRmVb+VvwiAGszHlOhleu//xnAM6r6DcdxZ73xHwN4qvq+FI+IHFpe0AsRORTA2Sid57UALi/f7HIA92czwrox4htYXvup87re1wL4VLkj2YdRajLwUhYDLCoRmQfgOgDzVfWA4/jEcmMfiMjvAzgGwPPZjLK4fP6uWQvgIhE5RESmoXT+f5H2+OrA/wfgV6q6u3KA1755XvNM5Ojv/qYsnzwPyp2wrgKwHkAjgNtV9emMh1V0swFcBuDJShtdAF8C8EkROQGltPWLAK7MZniF9j4A95X+bkMTgB+o6r+J/P/s3Xt83FWd//HXyX1yb5O0uTe90Qtt2kJaoFwECrSoFFwRWVBhWRdQC7u4wsqqwOK6PwTXC4q7i4q6rqt0ga0FXUFQRK5toNBaChToJZde09wzuc2c3x9nJjO5tUkmyWSS9/PxyCP5fr9nvnNmCE3eOed8jtkKbDTG/DWwH/hYFPs4qRljUnFVb8O/v+/V9/7YMMb8AjgXyDXGVAN3Avcw8Pf7b3BVyN4F2nDVQWWEBnnvbweSgd8F/h162Vp7I3AOcLcxphvwATdaa4dagEMGMMj7f+5A/9ZYa3caYzYCb+Kmtn5OFShHbqD33lr7I/qvfQZ974+FwX7PjJl/+7WNgIiIiIiISIzQFEoREREREZEYoQAnIiIiIiISIxTgREREREREYoQCnIiIiIiISIxQgBMREREREYkRCnAiIhLzjDEtgc9lxpirRvne/9jn+MXRvL+IiMhwKMCJiMhkUgYMK8AFN8k9jl4Bzlq7eph9EhERGTUKcCIiMpncA5xtjHndGHOLMSbeGHOfMWarMWa7MeYGAGPMucaYPxhj/hvYETi3yRjzqjFmpzHm+sC5ewBP4H4/D5wLjvaZwL3/bIzZYYz5eNi9nzXGPGKMecsY83MT2JVaREQkUgnR7oCIiMgo+iLwBWvthwECQazRWrvSGJMMvGCMeSrQdhWwxFq7J3B8nbX2mDHGA2w1xjxqrf2iMWaDtXb5AM/1F8ByYBmQG3jMc4FrK4CTgVrgBeBM4PnRf7kiIjLVaAROREQms4uATxljXgdeAXKA+YFrW8LCG8DNxpg3gJeBkrB2gzkL+IW11metPQT8EVgZdu9qa60feB03tVNERCRiGoETEZHJzAA3WWuf7HXSmHOB1j7HFwBnWGvbjDHPAilDuPdgOsK+9qGftyIiMko0AiciIpNJM5ARdvwk8BljTCKAMeYkY0zaAI/LAuoD4W0hcHrYta7g4/t4Dvh4YJ1dHnAOsGVUXoWIiMgg9BdBERGZTLYD3YGpkD8BvoObvvhaoJDIEeCyAR73W+BGY8x24G3cNMqgB4HtxpjXrLVXh53/X+AM4A3AArdZaw8GAqCIiMiYMNbaaPdBREREREREhkBTKEVERERERGKEApyIiIiIiEiMUIATEZEJI1AQpMUYUzqabUVERCYLrYETEZERM8a0hB2m4srn+wLHN1hrfz7+vRIREZm8FOBERGRUGGP2Ap+21j59nDYJ1tru8etVbNL7JCIig9EUShERGTPGmH82xjxsjPmFMaYZ+IQx5gxjzMvGmAZjzAFjzP1h+7QlGGOsMaYscPxfgev/Z4xpNsa8ZIyZPdy2gesXG2PeMcY0GmO+a4x5wRhz7SD9HrSPgetLjTFPG2OOGWMOGmNuC+vTV4wx7xljmowxlcaYQmPMPGOM7fMczwef3xjzaWPMc4HnOQZ82Rgz3xjzB2NMnTHmqDHmZ8aYrLDHzzLGbDLGHAlc/44xJiXQ50Vh7QqMMW3GmJyR/5cUEZGJQgFORETG2keA/8Ztlv0w0A38LZALnAmsA244zuOvAr4CTAf2A18dbltjzAxgI3Br4Hn3AKuOc59B+xgIUU8DjwMFwEnAs4HH3QpcHmifDXwaaD/O84RbDewC8oCvAwb458BzLAbmBF4bxpgE4NfAu7h97kqAjdba9sDr/ESf9+RJa23dEPshIiITmAKciIiMteettY9ba/3WWq+1dqu19hVrbbe19n3cRtkfOM7jH7HWVlpru4CfA8tH0PbDwOvW2l8Frn0LODrYTU7Qx/VAlbX2O9baDmttk7V2S+Dap4F/tNbuDrze1621x47/9vTYb639N2utL/A+vWOtfcZa22mtPRzoc7APZ+DC5T9Ya1sD7V8IXPspcFVg43KATwI/G2IfRERkgkuIdgdERGTSqwo/MMYsBP4VOBVX+CQBeOU4jz8Y9nUbkD6CtoXh/bDWWmNM9WA3OUEfS3AjXwMpAd47Tv+Op+/7lA/cjxsBzMD90fVI2PPstdb66MNa+4Ixphs4yxhTD5TiRutERGQS0AiciIiMtb7Vsv4D+DMwz1qbCdyBmy44lg4AxcGDwOhU0XHaH6+PVcDcQR432LXWwPOmhp3L79Om7/v0dVxVz6WBPlzbpw+zjDHxg/TjP3HTKD+Jm1rZMUg7ERGJMQpwIiIy3jKARqA1UGzjeOvfRssTwCnGmEsC68f+FrfWbCR93AyUGmM2GGOSjDGZxpjgerofAv9sjJlrnOXGmOm4kcGDuCIu8caY64FZJ+hzBi74NRpjSoAvhF17CagD/sUYk2qM8Rhjzgy7/jPcWryrcGFOREQmCQU4EREZb38PXAM040a6Hh7rJ7TWHgI+DnwTF3zmAttwI1zD6qO1thG4EPgocBh4h9DatPuATcAzQBNu7VyKdXv2/A3wj7i1d/M4/rRRgDtxhVYacaHx0bA+dOPW9S3CjcbtxwW24PW9wA6g01r74gmeR0REYoj2gRMRkSknMPWwFrjcWvunaPdnLBhj/hN431p7V7T7IiIio0dFTEREZEowxqzDTT1sB27HbRWw5bgPilHGmDnApcDSaPdFRERGl6ZQiojIVHEW8D5uCuM64LLJWNzDGPP/gDeAf7HW7o92f0REZHRpCqWIiIiIiEiM0AiciIiIiIhIjJiQa+Byc3NtWVlZtLshIiIiIiISFa+++upRa22/LW8mZIArKyujsrIy2t0QERERERGJCmPMvoHOawqliIiIiIhIjFCAExERERERiREKcCIiIiIiIjFiQq6BExGRgXV1dVFdXU17e3u0uyISkZSUFIqLi0lMTIx2V0REYooCnIhIDKmuriYjI4OysjKMMdHujsiIWGupq6ujurqa2bNnR7s7IiIxRVMoRURiSHt7Ozk5OQpvEtOMMeTk5GgkWURkBBTgRERijMKbTAb6PhaRqNu+Eb61BO7Kdp+3b4x2j4ZEUyhFRERERGRq2b4RHr8ZurzuuLHKHQOUXxG9fg2BRuBERGRY9u7dy5IlS8bk3s8++ywf/vCHAdi8eTP33HPPmDxPLBju+/yTn/yE2traE7bZsGFDpF0TEYltXV548kuh8BZ+/pm7o9OnYYhoBM4Ysw74DhAP/NBae0+f698CzgscpgIzrLXZkTyniIgM3aZtNdz35NvUNngpzPZw69oFXLaiKNrdGpL169ezfv36aHdjaLZvdD/0G6shqxjW3DHuf8H9yU9+wpIlSygsLBzX5wXo7u4mIUGTekRkArIWGvZBdSVUbYHqrXBwO/i7B27fWD2+/RuBEY/AGWPigQeAi4HFwF8aYxaHt7HW3mKtXW6tXQ58F3gsks6KiMjQbdpWw+2P7aCmwYsFahq83P7YDjZtq4n43t3d3VxzzTWUl5dz+eWX09bWxt13383KlStZsmQJ119/PdZaAO6//34WL15MeXk5V155JQCtra1cd911rFy5khUrVvCrX/2q33OEjxZde+213HzzzaxevZo5c+bwyCOP9LS77777WLlyJeXl5dx5550Rv7ZhC07DaawCbGgaziispRjq+/zII49QWVnJ1VdfzfLly/F6vWzdupXVq1ezbNkyVq1aRXNzMwC1tbWsW7eO+fPnc9ttt/U8V3p6Ol/60pdUeFsjAAAgAElEQVRYtmwZp59+OocOHQJg3759rFmzhvLyctasWcP+/fsB99/k85//POeddx7/8A//wF133cU111zDRRddRFlZGY899hi33XYbS5cuZd26dXR1dUX8foiInFBnG+x9AZ7/FvzyavjGSfCdZfDoX8O2n0FSGqy+CVJzB358VvH49ncEIvlz2SrgXWvt+wDGmF8ClwJvDtL+L4Eo/GQVEZmc/unxnbxZ2zTo9W37G+j0+Xud83b5uO2R7fxiy/4BH7O4MJM7Lzn5hM/99ttv86Mf/YgzzzyT6667ju9///ts2LCBO+64A4BPfvKTPPHEE1xyySXcc8897Nmzh+TkZBoaGgD42te+xvnnn89DDz1EQ0MDq1at4oILLjjucx44cIDnn3+et956i/Xr13P55Zfz1FNPsXv3brZs2YK1lvXr1/Pcc89xzjnnnPA1DNn/fREO7hj8evVW8HX0PtflhV9tgFd/OvBj8pfCxSeeHjrU9/nyyy/ne9/7Ht/4xjeoqKigs7OTj3/84zz88MOsXLmSpqYmPB4PAK+//jrbtm0jOTmZBQsWcNNNN1FSUkJrayunn346X/va17jtttv4wQ9+wJe//GU2bNjApz71Ka655hoeeughbr75ZjZt2gTAO++8w9NPP018fDx33XUX7733Hn/4wx948803OeOMM3j00Ue59957+chHPsKvf/1rLrvsshO/3yIiQ2Ut1O+Bqq3u3+LqLXDwz2B97vr0uTD3fChZCcWrYMZiiA/EnxmLe6+BA0j0uBkUE1wkAa4IqAo7rgZOG6ihMWYWMBv4fQTPJyIiw9A3vJ3o/HCUlJRw5plnAvCJT3yC+++/n9mzZ3PvvffS1tbGsWPHOPnkk7nkkksoLy/n6quv5rLLLuv5Bf6pp55i8+bNfOMb3wDc9gjBkZ3BXHbZZcTFxbF48eKe0aGnnnqKp556ihUrVgDQ0tLC7t27RzfAnUjf8Hai88MwnPc53Ntvv01BQQErV64EIDMzs+famjVryMrKAmDx4sXs27ePkpISkpKSetYfnnrqqfzud78D4KWXXuKxx9wEmk9+8pO9Ru0+9rGPER8f33N88cUXk5iYyNKlS/H5fKxbtw6ApUuXsnfv3ojfDxGZ4jpaoPY1F9aCoa3tqLuWlA5Fp8BZt0DxSveRljP4vYLT3KM8/X0kIglwA9X/tYO0vRJ4xNpgHB7gZsZcD1wPUFpaGkG3RESmhhONlJ15z++pafD2O1+U7eHhG86I6Ln7loA3xvDZz36WyspKSkpKuOuuu3r2+Pr1r3/Nc889x+bNm/nqV7/Kzp07sdby6KOPsmDBgl73CQazgSQnJ/d8HZyeaa3l9ttv54Ybbojo9RzXiUbKvrUkMH2yj6wS+KtfR/TUw3mfw1lrBy3TH/4+xsfH093t1oEkJib2PCb8/PH6lJaWNuC94+Liet0vLi5u0PuJiAzIWqh7LzSyVr0VDu0EG/gjZM58OGktFFcERtcWQVz88e/ZV/kVMRHY+oqkCmU1UBJ2XAwMVv7qSuAXx7uZtfZBa22FtbYiLy8vgm6JiAjArWsX4Ens/cPMkxjPrWsXDPKIodu/fz8vvfQSAL/4xS8466yzAMjNzaWlpaVnjZrf76eqqorzzjuPe++9l4aGBlpaWli7di3f/e53e4LYtm3bRtSPtWvX8tBDD9HS0gJATU0Nhw8fjvTlDc+aO9y0m3CjNA1nqO8zQEZGRs86t4ULF1JbW8vWrVsBaG5uHnGAWr16Nb/85S8B+PnPf97TBxGRUdXeBO8/C3+8D35+Bdw7B753Kmy6EXY84tasnf0FuPoRuG0P3FQJl30fKq6D/CXDD28xLJIRuK3AfGPMbKAGF9Ku6tvIGLMAmAa8FMFziYjIMAWrTY5FFcpFixbx05/+lBtuuIH58+fzmc98hvr6epYuXUpZWVnP1D2fz8cnPvEJGhsbsdZyyy23kJ2dzVe+8hX+7u/+jvLycqy1lJWV8cQTTwy7HxdddBG7du3ijDPciGJ6ejr/9V//xYwZMyJ+jUM2htNwhvo+gysqcuONN+LxeHjppZd4+OGHuemmm/B6vXg8Hp5++ukR9eH+++/nuuuu47777iMvL48f//jHEb8uEZni/H6oezc0sla1FQ6/Sc9kvryFsPCDbmSteCXkLZhSAe1ETPCvnyN6sDEfBL6N20bgIWvt14wxdwOV1trNgTZ3ASnW2i8O9b4VFRW2srJyxP0SEZmsdu3axaJFi6LdDZFRoe9nkSmivdGV8a+uDIS2Smh3Ra1IyYKiCihZ5aZDFlWAR7uOARhjXrXWVvQ9H9GmLdba3wC/6XPujj7Hd0XyHCIiIiIiEiP8fjj6dmBkLRDWjryFG10zbq3a4kvdyFrJKreWLS6SVV1Tj3bdFBERERGRkfHWQ/WroemQ1a9CR6O75pnmgtqSv3Cfi06FlMzj309OSAFORCTGHK/CoEisiGQJh4hEid/nRtOCI2vVW+DoO+6aiYMZJ7uwVrLKrV/LmQv6eTXqFOBERGJISkoKdXV15OTkKMRJzLLWUldXR0pKSrS7IiLH03YsMKoWmA5Z8xp0umq3pOa4UbXyj7vAVrgCkjOi298pQgFORCSGFBcXU11dzZEjR6LdFZGIpKSkUFxcHO1uiEiQr9tVggwGtuqtrlIkgImHmSfDso+HNsmePkeja1GiACciEkMSExOZPXt2tLshIiKxrvVoWKGRrW50ravVXUvLc1Mgl18dGl1LSotuf6WHApyIiIiISKzbvnHw/Sh9XXBoZ+/pkPV73LW4BMhfCiuudqGtZCVkz9Lo2gSmACciIiIiEsu2b4THb4YurzturIJffQ52POrWrNVug642dy19ppsCWfFXLrAVLIOk1Oj1XYZNAU5EREREJJb97s5QeAvydcLu37rS/adc40bWildCVolG12KcApyIiIiISCxpb4J9L8L7z8KeP0Jz7SANDfzN78ezZzIOFOBERERERCay7k63di0Y2KorwfogIQVKz4CmGmhv7P+4LFV6nYwU4EREREREJhK/Hw7tgPf/6ELb/pfcGjYTB4WnwFm3wJwPuDVsiSn918ABJHpcIROZdBTgRERERESiyVpXFTIY2PY8B95j7lruAljxSRfYZp0Jnuz+jw9WmxysCqVMKgpwIiIiIiLjreWImw4ZnBbZsN+dzyyCk9bBnHNh9jmQWTC0+5VfocA2RSjAiYiIiIiMtY7mQOGRQGg7vNOdT8mCsrNh9c0utOXMU5VIOS4FOBERERGR0dbdCTWVocBWUwn+bohPhtLTYc2dblpkwXKIi492byWGKMCJiIiIiETK73ejau8/60LbvhehqzVQeGRFaISt5DRXeERkhBTgRERERERGon5vKLDt+SO01bnzuSfB8qtcYCs7a+DCIyIjpAAnIiIiIjIUrUcDhUcC0yIb9rnzGQUw70IX2OZ8ADILo9hJmewU4EREREREBtLR4vZgC46yHdrhzidnweyz4YwNLrTlzlfhERk3CnAiIiIiIgC+Lqh5NRTYqreEFR45Dc7/Csw5DwqWQbx+jZbo0HeeiIiIiExN1sKhnaFpkftegM4WwEDhclh9E8z+gKsameiJdm9FAAU4EREREZlK6veFbaD9HLQecedz5sGyK11gKzsLUqdHtZsig1GAExEREZHJq7UO9j4XmhZZv8edT8+Huee7NWyzPwBZRVHspMjQKcCJiIiIyOTR2Qr7XoI9z7rAdnC7O5+c6UbWTv+MC2x5C1R4RGKSApyIiIiIxC5fF9S8FpoWWbUF/F0Qn+Q2zT7/yzD7XLeZtgqPyCSg72IRERGR8bB9IzxzNzRWQ1YxrLkDyq+Idq8mrsHeL2vh8K5QYNv7AnQ2A8ZVhzzjs4HCI2dAUmq0X4XIqFOAExERERlr2zfC4zdDl9cdN1a5Y1CIG8hA79evPgtbfgD1e6H1sDs/fS6Uf8ytYys7W4VHZEqIKMAZY9YB3wHigR9aa+8ZoM0VwF2ABd6w1l4VyXOKiIiIxJxn7g6FkaAuL/zmC9B8ELBuZMn6Q19j3W9P/c4N1K7vOYbYru85+lzz92436Dk7xHZ9zzFwu9pt4Ovs/X75uqCmEpZ8NFR4JLtkNP7riMSUEQc4Y0w88ABwIVANbDXGbLbWvhnWZj5wO3CmtbbeGDMj0g6LiIiIxAxfF+z9kxtBGkh7I/zuK8O/r4kDTKAIR+Dzcc8xxHbh58wwn8OEnmuoz0HgfFxc4HUFzvUNb0HWwkd/OPz3S2QSiWQEbhXwrrX2fQBjzC+BS4E3w9r8DfCAtbYewFp7OILnExEREZn4urzw3u9h1+Pw9v9BewMu1dj+bTOL4HOvMOSANFWqJn5rycChN6t4/PsiMsFEEuCKgPD/s6qB0/q0OQnAGPMCbprlXdba3w50M2PM9cD1AKWlpRF0S0RERGSctTfC7t/Brs3uc1cbpGTDgoth0SXgrXfTJcOnUSZ64IK7IDkjWr2euNbc0XsNHLj3a80d0euTyAQRSYAb6E9Aff+0lADMB84FioE/GWOWWGsb+j3Q2geBBwEqKioG+BOViIiIyATSehTe+rUbaXv/WVe6Pn0mLPtLF9rKzoL4xFD7+CRVoRyq4Pui90ukn0gCXDUQvnK0GKgdoM3L1touYI8x5m1coNsawfOKiIiIREdjNex6woW2/S+6AhzZs+C0G2DReiheGVrP1Vf5FQogw6H3S2RAkQS4rcB8Y8xsoAa4EuhbYXIT8JfAT4wxubgple9H8JwiIiIi4+vou25q5K7HofY1dy5vEZz9BTfSlr906qxNE5GoG3GAs9Z2G2M2AE/i1rc9ZK3daYy5G6i01m4OXLvIGPMm4ANutdbWjUbHRURERMaEtXBwe2ik7cgud77oVFhzpwttufOj20cRmbKMtRNvuVlFRYWtrKyMdjdERERkqvD7oXqLC2y7NkPDflf9cdaZLrAt/JAqIIrIuDLGvGqtreh7PqKNvEVERERiVnCPtl2Pu2IkLYdcoZE558I5t8KCD0JabrR7KSLSiwKciIiITB2dbW6PtreegLd/48r/J6bB/AvdSNv8CyElK9q9FBEZlAKciIiITG7tjfDOU25q5LtPh+3R9iEX2uae5/YYExGJAQpwIiIiMvm0HHEjbEPdo01EJEYowImIiMjkEMkebSIiMUIBTkRERGLX0d1he7Rtc+dmLHZFSBZ+WHu0icikowAnIiIisaNnj7bHA3u0veXOF50KF9wFCy+B3HnR7KGIyJhSgBMREZGJ7Xh7tFVcpz3aRGRKUYATERGRicfXBXuec6Ht7d+E7dF2HpxzGyy4WHu0iciUpAAnIiIiE0Nwj7Zdj8M7/zfAHm0XQUpmtHspIhJVCnAiIiISPdqjTURkWBTgREREZHy1HIG3fx3Yo+2P2qNNRGQYFOBERERk7DVUwVvBPdpeCu3RdvqNbo+2ogrt0SYiMgQKcCIiIjI2jrdH26JLYOYS7dEmIjJMCnAiIiIyMts3wjN3Q2O1K+O/5g7IW6A92kRExpACnIiIiAzf9o3w+M3Q5XXHjVXw2PWADduj7a8De7QVRbWrIiKTiQKciIiIDJ2vCw68Ab/5Qii89bDgmQYbKrVHm4jIGFGAExERkcF1d0DNq7DvBdj7AlRtga7Wwdt7GxTeRETGkAKciIiIhHS2QfVWF9j2vei+7m5312YshuVXQdmZ8Nt/hOba/o/PKh7f/oqITDEKcCIiIlNZRzPsfyUQ2F6AmtfcvmwmDvKXunVss1a7j9Tpocf5unqvgQO34faaO8b/NYiITCEKcCIiIlOJtx72vwx7n3cjbAfeAOsDEw+FK+CMz8Kss6D0NEjJGvw+5Ve4z32rUAbPi4jImFCAExERmcxaj7qgFlzDdujPgIX4JLd59tmfd6NrxasgOX149y6/QoFNRGScKcCJiIhMJs0HA6NrgTVswb3YEjxQshLOvd2tYSs61U15FBGRmKIAJyIiEssa9rugFgxtx95355PSofR0KP+425OtcAUkJEW3ryIiEjEFOBERkVhhrQtowdG1vS9A4353LSULSldDxXUusOWXQ7x+zIuITDb6l11ERGSishaOvB2qELnvRWg+4K6l5rq1a2d8zk2JnHEyxMVFt78iIjLmFOBEREQmCr8fDu90I2vBwNZ21F1Lz3dBbVbgI28BGBPd/oqIyLiLKMAZY9YB3wHigR9aa+/pc/1a4D6gJnDqe9baH0bynCIiIpOGrxsObg9ViNz/IrQ3umtZpTD/wsAebGfC9DkKbCIiMvIAZ4yJBx4ALgSqga3GmM3W2jf7NH3YWrshgj6KiIhMDt2dULsN9gX2YNv/CnQ2u2vT58Ci9VB2lgtt2aXR7auIiExIkYzArQLetda+D2CM+SVwKdA3wImIiExNXe1QUxmYEvk8VG2Fbq+7lrfQ7aEWHGHLLIhuX0VEJCZEEuCKgKqw42rgtAHafdQYcw7wDnCLtbZqgDYYY64HrgcoLdVfHUVEJAZ1tkLVK4HA9qILb75OwMDMJXDqNYE1bKshLTfavRURkRgUSYAbaCK+7XP8OPALa22HMeZG4KfA+QPdzFr7IPAgQEVFRd/7iIiITDztjW4a5L7nXWg78Dr4u8HEQ8EyWHW9mxJZejp4pkW7tyIiMglEEuCqgZKw42KgNryBtbYu7PAHwNcjeD4REZGxtX0jPHM3NFZDVjGsucNNcwxqO+ZG1oJl/Q/uAOuHuEQoOgVW3+xG2EpPg+SM6L0OERGZtCIJcFuB+caY2bgqk1cCV4U3MMYUWGsDG9awHtgVwfOJiIiMne0b4fGboSuwRq2xCjbfBNVb3X5s+16Aw4Fl3gkpULwSzrnVBbbilZCUGr2+i4jIlDHiAGet7TbGbACexG0j8JC1dqcx5m6g0lq7GbjZGLMe6AaOAdeOQp9FRERG3zN3h8JbUHc7bHkQEtOgZBUs+QsX2IpOhYTk6PRTRESmNGPtxFtuVlFRYSsrK6PdDRERmcx8XW4Ptv2vQNXL8OavBmlo4CtHID5xXLsnIiJTmzHmVWttRd/zEW3kLSIiEjO8DW465P6XXaXImlehq81dyyqFxNTQcbisYoU3ERGZMBTgRERk8rEW6ve6oBYMbId3AdZViMxfCqd8CkpOcxUiMwv7r4EDSPS4QiYiIiIThAKciIjEPl8XHNjupkIGA1vLIXctOdMVGTn5Iy6wFZ0Kyen97xGsNnm8KpQiIiJRpgAnIiKxx1sPVVsDgS0wHbI7MHKWXQqzP+BK+ZecDjMWQVz80O5bfoUCm4iITGgKcCIiMrFZC/V7QsVG9r8CRwK70ph4KCiHU68NBbbMgqh2V0REZCwpwImIyMTS3RmoDvlyKLC1HnbXkrOgZCUs+agLbEWnQlJadPsrIiIyjhTgREQkurz1ULUlrDrka2HTIWfB3PNCxUbyFg59OqSIiMgkpAAnIiLjx1o49n7v6pBH3nLXTDwULIOKv3KBreQ0TYcUERHpQwFORETGzgmnQ66CJZdrOqSIiMgQKcCJiMjoaTvWf7Ps7nZ3bVoZzD0/VGwkbyHExUW1uyIiIrFGAU5EREbmeNMh4xIgvxwqrnNr10pOg4z86PZXRERkElCAExGRoenuhANv9N4su/WIu5aSBcWrYOnlbnSt6FRISo1uf0VERCYhBTgRERlY2zFXHTK4dq32tT7TIddoOqSIiMg4U4ATEZHQdMjwYiNH33bX4hIC1SH/OhTYMmZGt78iIiJTlAKciMhktn0jPHM3NFZDVjGsuQPKr4DuDjcdMjgVsu90yJLTXLvS06HwFE2HFBERmSAU4EREJqvtG+Hxm6ErsCl2YxVs+gw8+3X3ta/DnZ82G+ZdENosO3eBpkOKiIhMUApwIiKThd8PzbVQ9y4c3Q1P3xUKbz1tuqFxP6y6PrRZtqZDioiIxAwFOBGRWNPeCEffdUGtbncgsL0Lx96DrrYTP97XBWu/Nvb9FBERkVGnACciMhF1d0L93v4hrW53aK0agImHabMgZx7MPgdy5kLufMiZDz+60E2V7CureNxehoiIiIwuBTgRkWixFpoPhkJa+Kha/T6wvlDbtDwXyk5aFwho89zxtDJISBr4/mvu6L0GDiDR486LiIhITFKAExEZax3NgWD2nlub1jOq9h50toTaJXhcMMsvhyUfDYW0nLngyR7+85Zf4T4PVIVSREREYpICnIjIaPB1Q8O+UAGRundDX7ccDGtoILvUjaKVnhEIafPccUbh6Fd/LL9CgU1ERGQSUYATERkqa936s56Qtjs0qla/x1V4DPJMd6Fs3preIW3abEhMid5rEBERkZimACci0ldnqwtmwVG0nsD2HnQ0htrFJ7vpjTMWwaJLwtamzYPU6dHrv4iIiJzQpm013Pfk29Q2eCnM9nDr2gVctqIo2t06IQU4EZma/D5o2B8Iart7T3tsqundNqvEhbLyKwIhba5bm5ZVDHHx0em/iIiIjNimbTXc/tgOvF2uYFhNg5fbH9sBMOFDnAKciMSW7RuHV5SjtS6sDH9YSDv2Pvg6Q+1SslwoKzsbcoPFQ+bB9DmQlDr2r0tERETGVGe3n4ON7VTXt3HX4zt7wluQt8vHfU++rQAnIjJqtm/sXRa/scod+zqhcEXvqY7B0OatDz0+LtEFstz5cNLaUEjLnQ+pOWBMdF6XiIiIRKy9y0d1vZeaBi819V6q69vCvvZyqLkda49/j9oG7/EbTAARBThjzDrgO0A88ENr7T2DtLsc+B9gpbW2MpLnFJEp7Jm7e+9pBu74V5/rfS6j0I2infwRF9KC0x6zSiFef7cSERGJRc3tXdQ0eKk+FghpDYGQFghtR1s6e7VPiDMUZKdQlO3hzHm5FE/zUDTNQ3G2h1s2vs6hpo5+z1GY7RmvlzNiI/5NxhgTDzwAXAhUA1uNMZuttW/2aZcB3Ay8EklHRWSK6u6A/S/Bu0+7EbfBXP5QYMrjXEhOH7/+iYiISMSstdS3dQXCWBvVgVGz8NG0pvbuXo9JSoijONuFssWFmRQFvi6elkpRtoeZmSnExw08u+b2ixf1WgMH4EmM59a1C8b0dY6GSP4UvQp411r7PoAx5pfApcCbfdp9FbgX+EIEzyUiU8mxPS6wvfs07HkOutogPgkSkl2g6yurxG18LSIiIhOS32852tJBdUMgmIUFteAIWltn7zVpaUnxLoxN83DqrGk9I2hF2S6k5aYnYUa4/CG4zm2qVaEsAsL/HF4NnBbewBizAiix1j5hjDlugDPGXA9cD1BaWhpBt0Qk5nS2wb4XXGDb/Ts49p47P60Mll8N8y+EsrPgrV/3XgMHkOhxhUxEREQkarp9fg42tfeEsfBgVl3fRm1DO50+f6/HZKcmUpTtYU5eGmfPzwuMngUDmocsT+KIA9pQXLaiKCYCW1+RBLiB3s2eZYHGmDjgW8C1Q7mZtfZB4EGAioqKEywvFJGYZq0rNvLu0/Du72DvC+DrgAQPzD4bTrsB5l3g1q2FC1abHE4VShEREYlYR7ePAw3tgWmNbT2FQaoDUxwPNrXj8/f+FT43PZniaR5OLspi7cn5YSNoblQtPVnr0kciknetGigJOy4GasOOM4AlwLOB5JwPbDbGrFchE5EpqKPZTYfc/Tt49xlo3O/O5y6AlZ+G+RdA6WpITDn+fcqvUGATERHpI9JNqds6u10o6zN6VlPvpjkeaenoVcExzkB+ZgpF0zysmj09bP2ZG0ErzPaQkqi9UsdCJAFuKzDfGDMbqAGuBK4KXrTWNgK5wWNjzLPAFxTeRKYIa+HQTjfC9u4zrhCJvxuS0mHOuXD2LW6ULVtTpkVERCIxlE2pG71dA5bWD1ZzPNbau4JjYryhMNuFsQ+clNerOEjxNA/5WSkkxseN7wsVIIIAZ63tNsZsAJ7EbSPwkLV2pzHmbqDSWrt5tDopIjHCWw/v/cEFtnefhpaD7vzMpXDGBreWrXgVJCRFt58iIiKTyNd/+9aAm1J/8dHt/Psf36Om3ktzR+8KjimJcYFRs1SWFmf1BLPiwBTHvIzkQSs4SnRFNPHUWvsb4Dd9zg1YTcBae24kzyUiE5DfDwdeD1WMrN4K1g8pWTD3fJh3ofucWRDtnoqIiMSUbp+futZOjjR3hD5aOnodH25u50hzB619qjcGtXf7KZ7m4bTZ03uNoBVN85CTNvIKjhJdWjkoIsPTejQ0wvbeM9BWBxgoXAHn3OqmRRaeog2zRURE+rDW0uTt5khLO4ePE8yOtnRQ19rZa81ZUEZKAnkZyeSlJ7O0OJu89GQeebWq3x5pAEXZHn54zcpxeGUynvQblogcn68bal4NrGV7GmpfByyk5rqwNu9CmHsepOWe8FYiIiKTUXuXb8AgNtBxZ7e/3+OT4uPIy0gmNyOZkumpnDJrGnnpyS6oBT8CxwMVBikvzorZTall+BTgRKS/pgOhaZHv/wHaG8HEufVr533JVYzMXwZxWrwsIiKTk89vORacwjhgMGvvOR5o9MsYmJ6a1BPA5uSl9QpieRnJzMhIJi89hUxPQkTTGWN5U2oZPmMHGpuNsoqKCltZqWKVIuOmuxOqXg6Etmfg0J/d+YwCmLfGjbLN+QB4pkW3nyIiIhGw1tLa6eNwU/sJR8zqWjv77WsGkJYUHwhfKQOOkAU/pqclqUqjRMQY86q1tqLveY3AiUxV9ftCgW3PH6GzBeISofR0uPBuNz1yxmL3J0QREZFxNpx9zTq7/dS1dnC4afCpi8Gv+1ZrBEiIM+QGAlh+ZgpLi7IGDGa56cmkafNpiTJ9B4pMFV3tsO/5UAGSo++481mlbmPseRfC7LMhOSO6/RQRkSnN57c8UlnFnY/vpL3LrRerafBy6yNv8Pu3DjEzM6VfKKtv6xrwXtmpieSlJzMjM5lTSrP7jJiFRtCyPYnEqWS+xAgFOJHJylqoe5L6lkUAACAASURBVC+0lm3v89DthfhkKDsLKq5zo2w58zTKJiIyDoYzojTRWGvp6PbT0eXH2+XD2+WjPexze5cPb6e//7ng+W4f7Z0+2rt9eDuDbXq393b6aO/2D1jkA6DLZ9n8xgFSEuN6pjDOyU3ntNk5A46W5aQnkZzQv+CHSKxTgBOZTDpaYO+fQqGtfq87nzMPTr3WBbZZqyEpNZq9FBGZcjZtq+lVJbCmwcvtj+0AiCjEdfv8tHf7XfjpFaoCQavTR0ef0OTt8tHRE658Az7etfH3CmojKZsQH2fwJMaTkhhPSmIcnsR4PEnxpCTEk+lJZGamq6oYauO+/tbT7wx4PwPsunud9i+TKU0BTiSWWQuHd4UC2/6XwNcJiWkw+xxYfRPMXQPTZ0e7pyIiU9q9T77Vb+2Vt8vHnZt39qzL6j165Q8LXWHn+oxwdflGVowuGKZ6h6c4PEnxZHkSSUkKng+ErsR4kgOfPUmh8z3nwu+VFNfz9UiLeGysrKKmwdvvfGG2R+FNpjwFOJFY421wRUeCBUiaatz5GYvhtBvdKFvp6ZCQHN1+iohMER3dPg43dXCgsZ0DjV4ONbVzoLGdg43tHGxynw80tg/42EZvF1/7zS4AEuNNr1Go8JCVnZrUKzyl9A1NwXOB0S3Xrv+olycpnuSEuAkfgm5du0D7mokMQgFOZKLz++Hg9tAoW9UWsD5IzoQ558K5X3SjbFmxsY5CRCSWtHZ09wljXg40tvcKaXWtnf0el5YUT35WCgVZHs6cl8uTfz5Ic0f/vcLyM1N4+u8/QEpCHAkqOd9D+5qJDE4BTiTatm+EZ+6GxmrIKoY1d7hA9v4fQqNsrYdd24JlcNYtbpStuALiE6PbdxGRGGWtpaGtq08Y83Kwz+hZ8wAbNE9LTSQ/y0NBVgrlxdkUZKUEwloK+Znu64yU3v8+nzUvd8ARpS9evJB0laUf0GUrihTYRAagfzFEomn7Rnj8ZugKzPNvrIL/vQFsoAKXZzrMPR/mX+g+p8+IXl9FRGKEz2852tLRM3XRBbOOfqNnHX2qHRoDMzKSyc/yMCcvjTPn5fYEs5mZoc8picOvbKgRJREZLcaOpKTQGKuoqLCVlZXR7obI2Pvm4tAatnDJmfDJTVC4HOJUAllEJKiz28+hpvaekbJDwZDW5HWjZo3tHGruwOfv/ftNUnwcM7OSAyNknl6hLBjS8tKTNY1RRCYMY8yr1tqKvuc1AicSDW3H4JV/Hzi8AXQ0Q/Gp49snEZEoa+sMW2/WGAxpXg42dvQEtKMt/debpfasN0vhjLm55Ge5UbSCwHTG/KwUpqcmaaNmEZkUFOBExlNTLbz4PXj1x9DVBgket7l2X1nF4983EZFhGurG1NZaGr1dgZGyUFXGQ43tHAgUBjnY2E7TAOvNslMTyQ+MlC0tyiI/09Mzahb8yEhOmPBVFUVERosCnMh4qHsPXvg2vP4Lt75t6cfgrL+Dgzt6r4EDSPS4QiYiIhPYQBtT3/bIGzy3+wgzM1MCIc3LoaYODjR6ae/qv94sLz2ZgqwUynLSOGNODvlZHjd6FhbSRrLeTERkMlOAExlLB3fA89+Cnf8LcYlw6jVuc+1pZe76jEXuc98qlOVXRK3LIiJ9+fyWA41e9tW1sbeulb1HW/nZS/to71MEpNNneey1GhLjDTMzXUXGkwszuWDRjMB6M09ovVlG8og3eRYRmcoU4ETGwv6X4U/fhN1PQlIGrL4ZTv8sZMzs37b8CgU2EYm6bp+f2oZ2F9DqWtl7tI19ga+rjnnp9IXCWnJCXL8KjkEGePurF2u9mYjIGFGAExkt1sJ7z7jgtu8FSM2B874Mqz4NnmnR7p2ICF0+P9X1XvYedcEsOKK2r66NqmNtdIdVbvQkxjMrJ5X5MzK4YPFMynLS3EduKjMzUjj73j9Q09B/DW9htkfhTURkDCnAiUTK74Ndj8Of/hUOboeMQlh3D5zyKUhKi3bvRGSK6ej2UXWsjb1H2/qFtJoGb6/y+unJCczKSWVxQSYXL8kPBLQ0ynJSyctIPm5hkFvXLhhwY+pb1y4Y09cnIjLVKcCJjFR3J+zYCM9/G+p2w/S5sP57UP5xSEiKdu9EZBJr7/KFBbNW9tYFpjsebaO20Uv4Fq8ZKQnMzk1jWUk2ly4v7BlFm5WTRk5a0oirN2pjahGR6FCAExmuzjbY9jN44X5oqob8pXD5j2Hxpdp0W0RGTWtHN/uCwawutB5tX10bBxrbe7WdlprIrJw0VpZNoyy3mLKcNGblpFKWk0Z2auKYldi/bEWRApuIyDhTgBMZKm8DbP0hvPxv0HYUSlfDJd+GeRe4etgiIsPU3N7Va4rj3qOhKY+Hmzt6tc1NT2JWThqr5+ZSlpPKrMBUx1nT08hKTYzSKxARkfGmACdyIi2H4eXvw9YfQUcTzLsQzv48zFod7Z6JSAxobOvqqezYN6zVtXb2ajsjI5my3DTOXZDHrEDRkFk5qczKSSUjRSFNREQU4EQG17AfXvwuvPaf0N0BJ18GZ90CBcui3TMRGSObttUMe02XtZb6QEjbF1Z+f09g2mNDW1ev9oVZKczKSeOik2cGQppbjzYrJ5XUJP1YFhGR49NPCpG+jrztCpPs2AgYWHYlnPl3kDsv2j0TkTG0aVtNr6qKNQ1ebn9sBwCXLi/kaEtnr/Voe8KmOza3d/fcxxgoyvZQlpPGh5YWhNaj5aZROj2VlEStlRURkZEzNrxU1XAfbMw64DtAPPBDa+09fa7fCHwO8AEtwPXW2jdPdN+KigpbWVk54n6JjEjNa/D8N2HXE5CQAqdeC6s3QFZxtHsmIuPgzHt+P+C+ZglxhuSEOFo7Q+Xy4+MMxdM8vUbQgp9LpntITlBIExGRyBhjXrXWVvQ9P+IROGNMPPAAcCFQDWw1xmzuE9D+21r774H264FvAutG+pwio85a2Pu8C27v/R6Ss+CcL8BpN0JabrR7JyJjxFpLdb2XXQea2HWgmV0HmgYMbwDdfssnKkrCCoekUTzNQ2J83Dj3WkREJLIplKuAd6217wMYY34JXAr0BDhrbVNY+zRg5MN9IqPJWnjnt/Cnb0L1FkibARf8E1RcBymZ0e6diIyi9i4fbx9sDoS1QGA72NQz7dEYmDU9lZTEONq7/P0eX5Tt4a71J493t0VERAYUSYArAqrCjquB0/o2MsZ8Dvg8kAScP9jNjDHXA9cDlJaWRtAtkePwdcPO/4XnvwWHd0J2KXzwG7DiE5DoiXbvRCQC1loONXWw60ATb/aEtSb2HG3FH/jzYVpSPAsLMrl0eSGLCjJZmJ/JwvwM0pIT+q2BA/AkxnPr2gVRekUiIiL9RRLgBtr4qt8Im7X2AeABY8xVwJeBawa6mbX2QeBBcGvgIuiXSH/dHfD6f8ML34b6vZC3ED7yH7DkoxCv0twisaaj28e7h1t6pj8GP+rDKj4WT/OwqCCTD5UXsrggg0UFmZRMSyUubuB9G4PVJodbhVJERGQ8RRLgqoGSsONioPY47X8J/FsEzycyfB0t8OqP4aUHoPkAFJ4CF30NFnwQ4rR+RSQWHG3p6D398UAT7x5uoTswrJacEMfC/AzWnpzPooJMN7JWkEHmCPZNu2xFkQKbiIhMaJEEuK3AfGPMbKAGuBK4KryBMWa+tXZ34PBDwG5ExkPbMXjlP2DLf4C3HmafA5f9G8w51y14EZEJp8vn5/0jrT1h7c0DTbx1sJkjzR09bfIzU1hUkMH5C2f0hLXZuWnEDzKqJiIiMtmMOMBZa7uNMRuAJ3HbCDxkrd1pjLkbqLTWbgY2GGMuALqAegaZPikyapoOwEvfg8ofQ1crLPgQnP15KO5XgVVEoqihrTOwTi00BXL3oRY6fa6ISFJ8HPNmpHPO/DwWFWSwuCCThQWZTE9LinLPRUREoiuifeDGivaBk2E79j688B23zs3vc2vbzroFZi6Ods9EpjSf37K3rrXfFMgDje09bXLTk3pG0xYF1qrNzUtXmX4REZnSRn0fOJEJ4dBOtxXAzscgLsFVk1x9M0yfHe2eiUw5ze1dvBVWrv/NA828c7C5p6pjfJxhbl4aq2ZP7xXYZmSkRLnnIiIisUMBTmJT1RYX3N75P0hKhzM2wBmfg4z8aPdMZNLz+90m2OGl+ncdbKLqWGgj7CxPIosKMrhyVQmLCjJZXJDJvBnppCTGR7HnIiIisU8BTmKHtfDe790ebnv/BJ5pcO4/wqq/gdTp0e6dyKTU1tkd2AQ7NLL21sFmWjpCm2DPzkmjvCibj1eU9IysFWSlYFQwSEREZNQpwMnE5/fDW0/An/4VDrwOGYWw9l/glGsgOT3avROZ0DZtqxnSvmbWWmob29lVGxpR23Wgmb11rQSXSqcnJ7CoIIO/OKWoJ6idNDOd1CT9KBERERkv+qkrE5evC3b8Dzz/bTj6NkybDZfcD8uuhITkaPdOZMLbtK2G2x/b0bMGrabBy+2P7aDL52dhfmZPqf7gqFqjN7QJdun0VBYVZHDp8sKeKZDF0zwaVRMREYkyBTiZeLq88NrP4MX7obEKZi6Bj/4IFl8G8fqWFRmqe3/7Vk94C/J2+bj1ke09x57EeBbkZ/DBpQUsDlSAXJCfQcYINsEWERGRsaffhmXiaG+ErT+Cl78PrUeg5DT40L/C/Iu0+bbIAPx+y8GmdqqOtbH/WFvoc72X/cfaem2A3dcDV53CooIMZuVoE2wREZFYogAn0ddyBF75N9jyA+hogrlr4Oy/h1mrFdxkymtq72J/XRvV9S6cuQ8v1cfaqK739mx8DRBnoCDLQ8l0D+ctyOO3fz5IU3t3v3sWZXv4UHnBeL4MERERGSUKcBI9DVXw4nfhtf+E7nZYvB7O+jwULo92z0TGTZfPT22Dl6pj3p6AVnWsjapAYGto6+rVPsuTSMl0DwsLMrjw5JmUTk+lZFoqpdNTKcz2kJQQ2vx69dzcXmvgwE2ZvHXtgnF7fSIiIjK6FOBk/B3d7QqTbP+lOy6/Es78W8g7Kbr9EhkD1lqOtXb2TG2sOtbG/rrgVMc2ahu8+G2ofWK8oXhaKsXTPHxoaQGl0104KwkEtazUoa9NC1abHEoVShEREYkNxlp74lbjrKKiwlZWVka7GzLaal+H578Jb26GhBQ45VOw+ibILol2z0Qi0t7lo7q+rdcoWs9I2rE2Wjt7FxLJTU+mdLqHkj7hrDQnlfzMFK1JExEREYwxr1prK/qe1wicjL7tG+GZu6GxGrKK3Qhb7Wvw3jOQnAVnfx5O+wyk50W7pyJD4vdbDjd39C4Uciw0inaoqXexkJTEuJ6Rs9Pn5PQeRZvu0b5pIiIiMmL6LUJG1/aN8PjNbisAcNsA/Ok+SEyHNXfCyr+GlKzo9lFkAM3tXVQd81JVHwpnofVoXjq7Q8VCjIGCzBRKpqdy9vy8fgEtLz1Z+6WJiIjImFCAk9H1zN2h8BbOk+1G3kQitGlbzYjWdHX7/BxobO81ehYe0I61dvZqn5GcQGlOKifNzGDNopk90x1dsZAUkhPix+olioiIiAxKAU5GT3enG3EbSFPN+PZFJqVN22p6VVWsafBy+2M7ALh0eSENbV090xp7T3f0UtPgxRdWLSQhzlA0zUPp9FTWFWX1VHIsDYyiZXkSNYomIiIiE44CnIyOgzvgfz8z+PWs4vHri0xK1lq+/tu3epXEB/B2+fjC/7zBVzb9meaO3nue5aQlUTI9leUl2axfVkhJWOGQ/MwUEuLjEBEREYklCnASGV8XPP8t+OPXwTMdTv8svPrj3tMoEz2w5o7o9VFiQmtHNwcavdQ2tPf6fKCxndoG97mtTzXHoG6/5aOnFlMcGFErzXFVHdOS9U+ciIiITC767UZG7tCbsOkzcOB1WPJR+OA3IHU6FK7oXYVyzR1QfkW0eytR1N7l40BjOwcavNSGf270cqChndpGL83tvUfPjIG89GQKsj3Mn5HBOSfl8eir1TT1aQdQlO3hrvUnj9fLEREREYkaBTgZPl83vHg/PPv/IDkDPvZTOPmy0PXyKxTYppDObj+HmkKjZLWBUBYcPTvQ2N6vQAi46Y0F2a6S42lzplOQ5aEwO4WCLA8FWSnMzEwhKaH3FMdlxdm91sABeBLjuXXtgjF/nSIiIiITgQKcDM+Rd9yoW00lLFoPH/qm9nObxLp9fg43dww4tfFgYzu1je0cbenA2t6Py0xJoDDbBbFlJdkUZgWCWXYKhVke8rNSSEkcfhXHYLXJkVShFBEREZkMFOBkaPw+ePn78MxXISkVPvojN21SVfpilt9vOdrS0XtKY4OXA02Bz43tHGpqx98nnKUlxVMQCGcL8zN7QllB2OjZWK49u2xFkQKbiIiITFkKcHJide+5UbeqV2DBB+HD34aMmdHulRyHtZZjrZ29CoDUBkbNgmvODjW10+Xrnc6SE+J6Rs5Wz80NTWkMGznLTElQeX0RERGRKFGAk8H5/bDlP+Dpf4KEJPjIg25tm355H1XD3ZjaWkuTt9utNQuuM2vov/aso9vf63GJ8Yb8wFTGilnTKMj29ExtzM9KoTDbw7RU7X0mIiIiMpEpwMnAju2BX30O9r0A8y+CS+6HzIJo92rSGWhj6i8+tp2DjV4WF2YNuZx+fJxhZoar2LikKIuLTs6nICsl8OFG0HLTkomLUzgTERERiWUKcNKb3w+VP4Lf3Qlx8XDpA7D8ao26jSK/31Lb6GXv0Tbu3Lyz38bU7V1+7vnt2z3H4eX0T5qZwQdOmuGCWWB6Y2F2CnnpydqUWkRERGQKUICTkIb98KsNsOePMPd8WP9dt4+bDJu1liPNHbx/tJW9R1vZU9fKniOt7K1rZV9dW7/pjQPZeMMZg5bTFxEREZGpKaIAZ4xZB3wHiAd+aK29p8/1zwOfBrqBI8B11tp9kTynjAFr4bWfwpNfcscf/jaceq1G3U7AWkt9Wxd7jrayp09Q21fXSmvYNMek+DhKc1Ipy0nj3AUzKMtJoyw3lc8//AYHm9r73bso28Oq2dPH8+WIiIiISAwYcYAzxsQDDwAXAtXAVmPMZmvtm2HNtgEV1to2Y8xngP/P3p3HR1Xd/x9/fbKQPQQIAbJA2EQQUTRo3RC3ihtiXbCKe1utazf7035ba237rV/121qrrbXWausCfMUi4r5bt0osboDIThICCUvIvp/fH3cSJhuZkGUyk/fz8ZjHzD33zp3PxJHkPefcc+4C5nWnYOlhe/Jh6Y2w/nXIPs4bMjlkTLCr6ldKq+u8cNYiqFWysbic0ur65uMiI4ysIXFkpyZwxNihjBueQPawBMamJpCeEkdkO9ef3XLagVqYWkREREQC1p0euCOAdc65DQBmtgA4G2gOcM65N/2O/xCY343Xk57kHHzyJLx0CzTWw+n3QM5VEDEwh+pV1TawaefekNYU1DbtrGBHeW3zcWaQPjiOsakJzDk0nexhCc1BLWtoPNFdvA5NC1OLiIiISFd0J8BlAHl+2/nAkfs4/irgxW68nvSU0kJ47iZY+zKMPhrmPgBDxwW7ql5XU99A3q5KNu6oZOOOcjbuqGzuWWs9jDEtKYbs1AROnjyC7NSE5qA2emg8sdGRPVqXFqYWERERkUB1J8C1d4GUa6cNM5sP5ADHd3gys+8A3wEYPXp0N8qSDjkHny2CF2+G+lqYfScccXVY9brVNzSSv7uKjTsrWg573FlBwe4qGv0+oUPioxmbmsDRE4YxdlgCY309admpCSTGaH4fEREREel/uvNXaj6Q5bedCWxtfZCZnQz8F3C8c66mo5M55x4CHgLIyclpNwhKN5QXwbLvw5fLIPMImPsnSJ0Q7Kr2S2Ojo7C0mk07KvbO8ui737Krknq/lJYUE0V2agLTs4ZwzvRMxqbGMzY1kbHDEhgcHx3EdyEiIiIi0nXdCXDLgYlmNhYoAC4ELvI/wMymA38GZjvnirrxWtIdXyyG538EtRVwyi/hqOu8Nd76saZp+Jt6z5qC2qYdlWzaWdFiGv7Y6AiyhyUwaWQSs6eOJDvVmzhkbGoCwxIGYZpNU0RERETCxH4HOOdcvZldD7yMt4zAI865lWZ2B5DrnFsK3A0kAv/n+yN6i3NuTg/ULYGo2AHP/xBWLYH0w+CcB2F4789uuGRFQcCTcuyuqN0bzloEtY6n4Z95QCpjUxPJTo1nbGoCI5JiiWhnhkcRERERkXBjzvW/0Yo5OTkuNzc32GWEtlVLvSGTNaUw61Y4+kaI7P3rupasKGgzLX5sdATXzZrA6GHxzT1oTUFtT1Vd83GREUbmEG+Gx6bp95tuHU3DLyIiIiISjszsY+dcTut2zdQQbip3wQs3wxdPw6hDYO5zMGJKr75kQ6OjqKyavF1V/OK5lS3CG0B1XSP/++pXwN5p+LNT4znrkFEtglrmkHgGRYXPhCoiIiIiIj1NAS6cfPmCtzxA1S444b/g2O9DZPcn6nDOUVxeQ96uKvJ3V5K/27tv2i4oqaKuofOe3Je/N5Mxw3p+Gn4RERERkYFCAS4cVO2Gl26FT5+CEVNh/mIYNS3gpzvn2F1Z1xzK8nZXtgho+burWkwaApCaOIjMIfFMzRjMaQePInNIHFlD4vnR/31KUVnbyUYzUuKYNDKp229VRERERGQgU4ALdWtfhaU3eMsEzPwxzLwZoga1OWxPVV2bUOa/7T9hCEBKfDSZQ+I4YEQSJx6YRtbQ+OaQljEkjvhB7X90fnL65DbXwMVFR3Lzqb0/eYqIiIiISLhTgAtV1Xvg5f+CFf+A4ZOpOvdxtsROIu+r3V4waxXQSqvrWzw9MSaKzCFxjB4Wz9EThpE1xBfQfEEtKXb/hl42zTYZ6CyUIiIiIiISOM1CGSKq6xrI3+0Nb2xY+wYzPruNpNpinok7l7trvsH2ypb/HWOjI9qEsqwh8c2PB8dFa300EREREZF+SrNQ9nO19Y1sLWm6/qyKvF2VzYEtf3cVxWU1JFDFT6Ke5OKo19ng0rk1/k7KUg/lJL+A1hTYtIC1iIiIiEj4UYDrI/UNjRTuqW4RyvJ3VTY/3lZajX9naFSEkZ4SR+aQOE6clMaRtpJT1/+S+MqtVBz+XbK/fht/jIkP3hsSEREREZE+pwAXgCUrCjq9pqux0bG9rLpl75lfL1rhnmoaGvcmtAiDkcmxZA6N56jxLa9Byxoaz4ikGKIiI6C2Al67HT56CIaOgwtfImH01/r4JyAiIiIiIv2BAlwnlqwoaDGrYkFJFTc//SmvrtpGclx0c1DbWlJNbUPLqfbTkmLIGhrP4WOGtLkebdTguM4Xrd78Piz5LuzeBEdeAyf9HAap101EREREZKBSgOvE3S+vaTElPkBdg+P5z7cxLGEQmUPjOShjMLOnjmoR0DJS4vZ/weraSnjjV/DhHyFlNFz+PGQf2wPvRkREREREQpkCXCe2llS1227Axz87pedfMO8jr9dt5zqY8S04+RcQk9jzryMiIiIiIiFHAa4T6SlxFLQT4tJT4nr2heqq4c1fwwf3Q3IGXPosjJvVs68hIiIiIiIhrZOLsOTmUycR12ooZFx0JDefOqnnXqTgY/jzTHj/Pph+CXz3fYU3ERERERFpQz1wnWiabbKzWSj3S30NvP0/8O69kDgC5i+GCSd3/7wiIiIiIhKWFOACMHd6Rs8ENn9bP/GudStaBYdeDKf+N8Sl9OxriIiIiIhIWFGA62v1tfCv/4V/3QPxqfDNhTBpdrCrEhERERGREKAA15e2fQFLroFtn8O0eTD7TogfGuyqREREREQkRCjA9YWGenjvd/DW/3jDJOc9AZPPDHZVIiIiIiISYhTgelvRavjnNVD4CRz0DTj9HkgYFuyqREREREQkBCnA9ZaGevjgD/Dmf0NMEpz/KBx0TrCrEhERERGREKYA1xt2rPV63QpyYfJZcMbvIHF4sKsSEREREZEQpwDXkxob4MM/wRu/hKhYOPevMPVcMAt2ZSIiIiIiEgYU4HrKzvWw5FrI+xAOOA3OuheSRga7KhERERERCSMKcN3V2AjL/wKv/hwiB8HcB+GQC9XrJiIiIiIiPU4Brjt2bYRnr4fN78KEU2DOfZCcHuyqREREREQkTCnA7Y/GRvj4EXjlNrAImHM/TJ+vXjcREREREelV3QpwZjYb+D0QCTzsnLuz1f6ZwL3ANOBC59zT3Xm9oPlsEbx+B+zJ965rixkMO76EcbO88JaSFewKRURERERkANjvAGdmkcADwClAPrDczJY651b5HbYFuBz4UXeKDKrPFsFzN0JdlbddVujdDr0Yzn5AvW4iIiIiItJnutMDdwSwzjm3AcDMFgBnA80Bzjm3ybevsRuvE1yv37E3vPnb+I7Cm4iIiIiI9KmIbjw3A8jz2873te0XM/uOmeWaWW5xcXE3yuphe/K71i4iIiIiItJLuhPg2ut+cvt7MufcQ865HOdczvDhw7tRVg8bnNm1dhERERERkV7SnQCXD/jP3pEJbO1eOf3QSbdBdFzLtug4r11ERERERKQPdSfALQcmmtlYMxsEXAgs7Zmy+pFpF8BZ98HgLMC8+7Pu89pFRERERET60H5PYuKcqzez64GX8ZYReMQ5t9LM7gBynXNLzWwG8E9gCHCWmf3COXdQj1Tel6ZdoMAmIiIiIiJB16114JxzLwAvtGq7ze/xcryhlSIiIiIiItJN3RlCKSIiIiIiIn1IAU5ERERERCREKMCJiIiIiIiECAU4ERERERGREKEAJyIiIiIiEiLMORfsGtows2Jgc7DraEcqsCPYRUjY0udLepM+X9Kb9PmS3qTPl/S2/voZG+OcG966sV8GuP7KzHKdcznBrkPCkz5f0pv0+ZLepM+X9CZ9vqS3hdpnTEMoRUREREREQoQCnIiIiIiISIhQgOuah4JdgIQ1fb6kN+nzJb1Jny/pTfp8SW8Lqc+YroETEREREREJUTZkXAAAIABJREFUEeqBExERERERCREKcCIiIiIiIiFCAS4AZjbbzNaY2TozuyXY9Uj4MLMsM3vTzFab2UozuynYNUn4MbNIM1thZsuCXYuEHzNLMbOnzexL379lRwW7JgkfZvZ93+/HL8zsKTOLDXZNErrM7BEzKzKzL/zahprZq2a21nc/JJg1BkIBrhNmFgk8AJwGTAG+aWZTgluVhJF64IfOucnA14Dr9PmSXnATsDrYRUjY+j3wknPuQOAQ9FmTHmJmGcCNQI5zbioQCVwY3KokxD0KzG7VdgvwunNuIvC6b7tfU4Dr3BHAOufcBudcLbAAODvINUmYcM4VOuf+43tchveHT0Zwq5JwYmaZwBnAw8GuRcKPmSUDM4G/Ajjnap1zJcGtSsJMFBBnZlFAPLA1yPVICHPOvQPsatV8NvCY7/FjwNw+LWo/KMB1LgPI89vOR39gSy8ws2xgOvDv4FYiYeZe4MdAY7ALkbA0DigG/uYbpvuwmSUEuygJD865AuAeYAtQCOxxzr0S3KokDI1wzhWC98U6kBbkejqlANc5a6dNay9IjzKzRGAx8D3nXGmw65HwYGZnAkXOuY+DXYuErSjgMOBPzrnpQAUhMPxIQoPvWqSzgbFAOpBgZvODW5VI8CnAdS4fyPLbzkTd99KDzCwaL7w94Zx7Jtj1SFg5BphjZpvwhn+faGaPB7ckCTP5QL5zrmnkwNN4gU6kJ5wMbHTOFTvn6oBngKODXJOEn+1mNgrAd18U5Ho6pQDXueXARDMba2aD8C6eXRrkmiRMmJnhXTuy2jn322DXI+HFOXercy7TOZeN92/XG845fXstPcY5tw3IM7NJvqaTgFVBLEnCyxbga2YW7/t9eRKaJEd63lLgMt/jy4Bng1hLQKKCXUB/55yrN7PrgZfxZj96xDm3MshlSfg4BrgE+NzMPvG1/cQ590IQaxIR6YobgCd8X3JuAK4Icj0SJpxz/zazp4H/4M3avAJ4KLhVSSgzs6eAWUCqmeUDPwfuBBaZ2VV4XxqcH7wKA2PO6XIuERERERGRUKAhlCIiIiIiIiFCAU5ERERERCREKMCJiIiIiIiECAU4ERERERGREKEAJyIiIiIiEiIU4EREJGyZWYOZfeJ3u6UHz51tZl/01PlEREQCoXXgREQknFU55w4NdhEiIiI9RT1wIiIy4JjZJjP7HzP7yHeb4GsfY2avm9lnvvvRvvYRZvZPM/vUdzvad6pIM/uLma00s1fMLC5ob0pERAYEBTgREQlnca2GUM7z21fqnDsCuB+419d2P/B359w04AngPl/7fcDbzrlDgMOAlb72icADzrmDgBLg3F5+PyIiMsCZcy7YNYiIiPQKMyt3ziW2074JONE5t8HMooFtzrlhZrYDGOWcq/O1FzrnUs2sGMh0ztX4nSMbeNU5N9G3/f+AaOfcr3r/nYmIyEClHjgRERmoXAePOzqmPTV+jxvQteUiItLLFOBERGSgmud3/4Hv8fvAhb7HFwPv+h6/DnwXwMwizSy5r4oUERHxp28KRUQknMWZ2Sd+2y8555qWEogxs3/jfZn5TV/bjcAjZnYzUAxc4Wu/CXjIzK7C62n7LlDY69WLiIi0omvgRERkwPFdA5fjnNsR7FpERES6QkMoRUREREREQoR64EREREREREKEeuBERKRPmFm2mTkzi/Jtv2hmlwVy7H681k/M7OHu1CsiItIfKcCJiEhAzOxlM7ujnfazzWxbV8OWc+4059xjPVDXLDPLb3Xu/3bOfau75xYREelvFOBERCRQjwKXmJm1ar8EeMI5V9/3JQ0s+9sjKSIi4UMBTkREArUEGAoc19RgZkOAM4G/+7bPMLMVZlZqZnlmdntHJzOzt8zsW77HkWZ2j5ntMLMNwBmtjr3CzFabWZmZbTCzq33tCcCLQLqZlftu6WZ2u5k97vf8OWa20sxKfK872W/fJjP7kZl9ZmZ7zGyhmcV2UPN4M3vDzHb6an3CzFL89meZ2TNmVuw75n6/fd/2ew+rzOwwX7szswl+xz1qZr/yPZ5lZvlm9v/MbBvwNzMbYmbLfK+x2/c40+/5Q83sb2a21bd/ia/9CzM7y++4aN97OLSj/0YiItL/KMCJiEhAnHNVwCLgUr/mC4AvnXOf+rYrfPtT8ELYd81sbgCn/zZeEJwO5ADntdpf5NufjLc22+/M7DDnXAVwGrDVOZfou231f6KZHQA8BXwPGA68ADxnZoNavY/ZwFhgGnB5B3Ua8BsgHZgMZAG3+14nElgGbAaygQxggW/f+b7jLvW9hznAzgB+LgAj8YLzGOA7eL+7/+bbHg1UAff7Hf8PIB44CEgDfudr/zsw3++404FC55z/OnkiItLPKcCJiEhXPAacb2Zxvu1LfW0AOOfecs597pxrdM59hhecjg/gvBcA9zrn8pxzu/BCUjPn3PPOufXO8zbwCn49gZ2YBzzvnHvVOVcH3APEAUf7HXOfc26r77WfA9rtlXLOrfOdp8Y5Vwz81u/9HYEX7G52zlU456qdc+/69n0LuMs5t9z3HtY55zYHWH8j8HPfa1Y553Y65xY75yqdc2XAr5tqMLNReIH2Gufcbudcne/nBfA4cLqZJfu2L8ELeyIiEkIU4EREJGC+QFIMnG1m44AZwJNN+83sSDN70ze8bw9wDZAawKnTgTy/7RbhxsxOM7MPzWyXmZXg9R4Fct6mczefzznX6HutDL9jtvk9rgQS2zuRmaWZ2QIzKzCzUrxQ1FRHFrC5g2sBs4D1AdbbWrFzrtqvhngz+7OZbfbV8A6Q4usBzAJ2Oed2tz6Jr2fyPeBc37DP04An9rMmEREJEgU4ERHpqr/j9bxdArzinNvut+9JYCmQ5ZwbDDyIN+ywM4V44aPJ6KYHZhYDLMbrORvhnEvBGwbZdN7OFjTdijfcsOl85nutggDqau03vteb5pxLxhuS2FRHHjC6g4lG8oDxHZyzEm/IY5ORrfa3fn8/BCYBR/pqmOlrN9/rDPW/Lq+Vx3w1nw984Jzbn5+BiIgEkQKciIh01d+Bk/GuW2u9DEASXg9QtZkdAVwU4DkXATeaWaZvYpRb/PYNAmLwev7qzew04Ot++7cDw8xs8D7OfYaZnWRm0XgBqAZ4P8Da/CUB5UCJmWUAN/vt+wgviN5pZglmFmtmx/j2PQz8yMwON88EM2sKlZ8AF/kmcplN50NOk/Cueysxs6HAz5t2OOcK8SZ1+aNvspNoM5vp99wlwGHATfgmnhERkdCiACciIl3inNuEF34S8Hrb/F0L3GFmZcBteOEpEH8BXgY+Bf4DPOP3emXAjb5z7cYLhUv99n+Jd63dBt8sk+mt6l2D1+v0B2AHcBZwlnOuNsDa/P0CLwDtAZ5vVWeD79wTgC1APt71dzjn/g/vWrUngTL2zugJXpg6CygBLvbt25d78a7h2wF8CLzUav8lQB3wJd7kL9/zq7EKrzdzrH/tIiISOsy5zkaeiIiISLgws9uAA5xz8zs9WERE+h0tCCoiIjJA+IZcXoXXSyciIiFIQyhFREQGADP7Nt4kJy86594Jdj0iIrJ/NIRSREREREQkRATUA2dms81sjZmtM7Nb2tl/jZl9bmafmNm7ZjbF155tZlW+9k/M7MGefgMiIiIiIiIDRac9cL6FQb8CTsGbUWs58E3n3Cq/Y5Kdc6W+x3OAa51zs80sG1jmnJvalaJSU1NddnZ2V54iIiIiIiISNj7++OMdzrnhrdsDmcTkCGCdc24DgJktAM4GmgNcU3jzSaDzRVX3KTs7m9zc3O6cQkREREREJGSZ2eb22gMZQpmBd9Fzk3xfW+sXuM7M1gN34a3X02Ssma0ws7fN7Lh9FPgdM8s1s9zi4uIAyhIRERERERlYAglw1k5bmx4259wDzrnxwP8DfuprLgRGO+emAz8AnjSz5PZexDn3kHMuxzmXM3x4m55CERERERGRAS+QAJcPZPltZwJb93H8AmAugHOuxjm30/f4Y2A9cMD+lSoiIiIiIjKwBXIN3HJgopmNBQqAC4GL/A8ws4nOubW+zTOAtb724cAu51yDmY0DJgIbeqp4EZGBpq6ujvz8fKqrq4Ndiki3xMbGkpmZSXR0dLBLEREJKZ0GOOdcvZldD7wMRAKPOOdWmtkdQK5zbilwvZmdDNQBu4HLfE+fCdxhZvVAA3CNc25Xb7wREZGBID8/n6SkJLKzszFrb4S7SP/nnGPnzp3k5+czduzYYJcjIhJSAumBwzn3AvBCq7bb/B7f1MHzFgOLu1OgiIjsVV1drfAmIc/MGDZsGJq0TESk6wJayFtERPoPhTcJB/oci/SwzxbB76bC7Sne/WeLgl2R9JKAeuBERERERKSf+mwRPHcj1FV523vyvG2AaRcEry7pFeqBExEJY0tWFHDMnW8w9pbnOebON1iyoqDb59y0aRNTp07tgeraeuuttzjzzDMBWLp0KXfeeWevvE6P64Vvvrv6c3700UfZunVfk0R7x1x//fXdLU1E+pPSQnjp1r3hrUldFSz7Pvzrt/DJk7D+Ddi+Cip3gWuzIpiEEPXAiYiEqSUrCrj1mc+pqmsAoKCkiluf+RyAudMzgllaQObMmcOcOXOCXUbn+sk3348++ihTp04lPT29z16zSX19PVFR+pNCpNeVFsLWFVD4CWz9xLsv397x8bXl8Pov2rZHxkDSCEgaBUkjIXGkd998GwWJIyBuCGi4c7+jf21FRELUL55byaqtpR3uX7GlhNqGxhZtVXUN/Pjpz3jqoy3tPmdKejI/P+ugTl+7vr6eyy67jBUrVnDAAQfw97//nXvuuYfnnnuOqqoqjj76aP785z9jZtx33308+OCDREVFMWXKFBYsWEBFRQU33HADn3/+OfX19dx+++2cffbZLV7j0UcfJTc3l/vvv5/LL7+c5ORkcnNz2bZtG3fddRfnnXceAHfffTeLFi2ipqaGc845h1/8op0/VrrjxVtg2+cd789fDg01LdvqquDZ6+Hjx9p/zsiD4bTOexcD/TkvXryY3NxcLr74YuLi4vjggw/44osvuOmmm6ioqCAmJobXX38dgK1btzJ79mzWr1/POeecw1133QVAYmIiN910E8uWLSMuLo5nn32WESNGsHnzZq688kqKi4sZPnw4f/vb3xg9ejSXX345Q4cOZcWKFRx22GEkJSWxceNGCgsL+eqrr/jtb3/Lhx9+yIsvvkhGRgbPPfeclgwQ6YrSQl9QW9E2rFkEpB4A406A9EO9XraKorbnGJwF130E5dugbBuUFULZdt/9Nq+9aDWsfwtq9rR9fmRMy2CX6Bfw/ANgbIqCXh9SgBMRCVOtw1tn7V2xZs0a/vrXv3LMMcdw5ZVX8sc//pHrr7+e227zJii+5JJLWLZsGWeddRZ33nknGzduJCYmhpKSEgB+/etfc+KJJ/LII49QUlLCEUccwcknn7zP1ywsLOTdd9/lyy+/ZM6cOZx33nm88sorrF27lo8++gjnHHPmzOGdd95h5syZ3X6PAWsd3jpr74JAf87nnXce999/P/fccw85OTnU1tYyb948Fi5cyIwZMygtLSUuLg6ATz75hBUrVhATE8OkSZO44YYbyMrKoqKigq997Wv8+te/5sc//jF/+ctf+OlPf8r111/PpZdeymWXXcYjjzzCjTfeyJIlSwD46quveO2114iMjOT2229n/fr1vPnmm6xatYqjjjqKxYsXc9ddd3HOOefw/PPPM3fu3G7/TETCUnNY+2RvD1tzz5rB8El7w9qoQ70vgWIS9z4/fljLkQAA0XFw0m0wKB6GjvNu+1Jb4Qt1fgGv6dYc9N6Emna+OGwd9Jp68JoCXtNNQa9HKMCJiISoznrKjrnzDQpKqtq0Z6TEsfDqo7r12llZWRxzzDEAzJ8/n/vuu4+xY8dy1113UVlZya5duzjooIM466yzmDZtGhdffDFz585t/gP+lVdeYenSpdxzzz2AtzzCli3t9wo2mTt3LhEREUyZMoXt27c3n+eVV15h+vTpAJSXl7N27dqeDXCd9ZT9bqo3bLK1wVlwxfPdeumu/Jz9rVmzhlGjRjFjxgwAkpOTm/eddNJJDB48GIApU6awefNmsrKyGDRoUPP1h4cffjivvvoqAB988AHPPPMM4AXGH//4x83nOv/884mMjGzePu2004iOjubggw+moaGB2bNnA3DwwQezadOmbv0sRMKGf1hrui/f5ttpLXvW2gtr7Wkarv36HbAnHwZneuGtK8O4ByXAsPHebV+agl5TsPMPemWFAQa9Ufsewqmgt08KcCIiYermUye1uAYOIC46kptPndTtc7eeAt7MuPbaa8nNzSUrK4vbb7+d6upqAJ5//nneeecdli5dyi9/+UtWrlyJc47FixczaVLLWpqCWXtiYmKaHzvfBfjOOW699Vauvvrqbr+n/XbSbR1/891NXfk5+3POdThNv//PMTIykvr6eq/k6Ojm5/i376umhISEds8dERHR4nwREREdnk8krJVtazkEst2wdjykTw88rHVk2gV9c91tt4Ke3xDO7as6DnpRse334LUewtndoPfZou6F3iBRgBMRCVNNE5Xc/fIatpZUkZ4Sx82nTuqRCUy2bNnCBx98wFFHHcVTTz3Fsccey/vvv09qairl5eU8/fTTnHfeeTQ2NpKXl8cJJ5zAsccey5NPPkl5eTmnnnoqf/jDH/jDH/6AmbFixYrmXrSuOPXUU/nZz37GxRdfTGJiIgUFBURHR5OWltbt9xiwnvjmuwOB/pwBkpKSKCsrA+DAAw9k69atLF++nBkzZlBWVtY8hLKrjj76aBYsWMAll1zCE088wbHHHtvt9yUSlsq2+QW1FR2HtVGHeoGtO2EtFOxP0CsrbDuEc/tKbwbNjoLeviZh2VfQ6ycTUO0PBTgRkTA2d3pGr8w4OXnyZB577DGuvvpqJk6cyHe/+112797NwQcfTHZ2dvPQvYaGBubPn8+ePXtwzvH973+flJQUfvazn/G9732PadOm4ZwjOzubZcuWdbmOr3/966xevZqjjvKGhCYmJvL444/3bYCDXvvmO9CfM8Dll1/ONddc0zyJycKFC7nhhhuoqqoiLi6O1157bb9quO+++7jyyiu5++67mycxERnwWoQ1X2DrMKwdCiOnhXdY645Ag15NuS/cbWs5CYt/0Fv3OtSWtX1um6A3Cj59sv2lF16/o98HOHP9cB2InJwcl5ubG+wyRET6ndWrVzN58uRglyHSI/R5lpDQOqwVfuIFCMALaxP3DoFMbxoGmRTUkge05qBXuI9r9ba1H/QAMLi9pE9L7oiZfeycy2ndrh44ERERERHwrs9qvc5a67CWfZwX2BTW+qeYRO/WWY/eb6dAaUHb9sGZvVNXD1KAExEREZGBp2x726n72w1r/tesKayFjZNv77UJqHqbApyISIjZ1wyDIqGiP17CIWHMP6w1TTLSUVgbdSiMmqawFu56cQKq3qYAJyISQmJjY9m5cyfDhg1TiJOQ5Zxj586dxMbGBrsUCUdtwtonULbVt9Ng2ASFNfH01dILPUwBTkQkhGRmZpKfn09xcXGwSxHpltjYWDIz+/+1JhJEgazRVV7Ucghku2HtmL2TjCisSRhQgBMRCSHR0dGMHTs22GWIiPSu9tboWnoDFH4OsUl711lrL6w1rbOmsCZhSgFORERERHpHY4MXwuqqoN53X1cJddXefX1127a6KvjwgbZrdNVXwwf30Tas+dZZi00OylsU6WsKcCIiIiJ9IZAhgX3BOb/gVOV7XLl3u92wVeUXuFqFrXbbfM9vqO3h4g1u2aKwJgOaApyIiIjsn/4SSEJBe0MCn7vRe9z0M2uoa6d3qilYtddW1SpYtdfWXgCrAvZjFtCIKIiO96Zaj4r1Pfbdxw2BpFZt0XEQFefd+9/atMW3PF9UHPx+mvczam1wpsKbDHgKcCIiItJ1gQSSfXHOG17nGlret9tWD64xwLYGaGwMsK1h7znaa3O+9g7b/M/bSduWf0NDTcufQV0V/PNqWPYDr8eqsX4//kNYy9AUFbs3FEXHQfwwv3AU1+q4+E6CVVzLc0ZG70d9++mk20J2jS6R3qYAJyIiIl3T2Aiv/LTtNUp1VfDPa+DVn3cezFxjcGrvCosAi/R6niIifY87aIuI8j3uoK11eGviGuGwS33BqnVvVCfhKioOomIgHJcUCeE1ukR6mwKciIiI7FtjI2z/Aja96902vwfVJe0f6xpgwomtwkxT2InoRluAQanp3v9xh22d1NCTweh3UzsYEpgFs/+7514nnIToGl0ivU0BTkRERFraV2AbOg6mzIHVy6BqV9vnDs6Csx/o23pDgYYEikgPUYATEREZ6PYV2IaMhclnQfZx3rTtg32Lb2cfp0DSFRoSKCI9RAFORERkoNmfwNaaAknXaUigiPQABTgREZFw19gIRSv3BrZN73Y9sLVHgUREpM8pwImIiISb3gpsIiISdApwIiIioW6fgS0bJp/pBbYxx0BKVlBLFRGR7lGAExERCTWtA9vm96Bqt7dPgU1EJKwpwImIiPR3jY1QtMoX2P7VNrAdeIYCm4jIAKEAJyIi0t8osImISAcU4ERERIJtX4EtZQxMOgOyj/UmHUkZHdxaRUQkqBTgRERE+poCm4iI7CcFOBERkd7W2AjFq/cGtk3vQdUub58Cm4iIdIECnIiISE/rNLCdrsAmIiL7RQFORESku/YZ2EbDpNO8wDbmGBgyJri1iohISFOAExER6SoFNhERCRIFOBERkSafLYLX74A9+TA4E066DaZd4AtsX7acdKRyp/ccBTYREelDAQU4M5sN/B6IBB52zt3Zav81wHVAA1AOfMc5t8q371bgKt++G51zL/dc+SIiIj3ks0Xw3I1QV+Vt78mDJdfCh3+Cks17A9vg0XDAbAU2EREJik4DnJlFAg8ApwD5wHIzW9oU0HyedM496Dt+DvBbYLaZTQEuBA4C0oHXzOwA51xDD78PERGRwNRWQHkRVOyAiiKoKPZu7967N7w1aayDwk9h2jzfpCPHKrCJiEhQBdIDdwSwzjm3AcDMFgBnA80BzjlX6nd8AuB8j88GFjjnaoCNZrbOd74PeqB2ERERb3hj1S4vhJU3BTK/cFZevDekVRRDXWXXzu8a4Zw/9U7tIiIiXRRIgMsA8vy284EjWx9kZtcBPwAGASf6PffDVs/NaO9FzOw7wHcARo/WlMoiIgNaXXXL0NUczvx7zXZ4bZU7vJDVmkVCQiokpHn3w8ZDwvCWt0S/x3843Bs22drgzN5/vyIiIgEKJMBZO22uTYNzDwAPmNlFwE+BywJ9ru/5DwEPAeTk5LR7jIiIhCjnoLpkb+hqE8z8e812QE1p++eJTtgbulLGQMbhviCW5hfWfNuxKRAREXiNJ93W8ho4gOg4r11ERKSfCCTA5QNZftuZwNZ9HL8AaBpr0tXniohIqGio62CoYlNPmX+vWbF3PVkbBvHD9vaGpU9v1UPmC2QJqd79oITeez/TLvDu25uFUkREpJ8IJMAtByaa2VigAG9Skov8DzCzic65tb7NM4Cmx0uBJ83st3iTmEwEPuqJwkVEJAAdTYvfHuegtrztUMXW15A1BbPqkvbPExmzt0csaRSMnOY3VDFtbxhLTIO4oRDZj1a0mXaBApuIiPRrnf7WdM7Vm9n1wMt4ywg84pxbaWZ3ALnOuaXA9WZ2MlAH7MYbPonvuEV4E57UA9dpBkoR6ZauBJJw55x37VdjA7iGlveNDbBqCbzyU6iv9o7fkwfPXgdrX4XBGe2Hs6ZjW4tN2Ru60ibD2OP39ow195L5bjFJYO2NoBcREZHuMuf63+VmOTk5Ljc3N9hliEh/03qdLoCoGDjmBzDu+PZDTKdt9d4shgG1NewNTI31fvu709bgvVabtgDr318RUfuY0COt5XZ8KkQN6v5/PxEREQmYmX3snMtp3d6Pxq2IiOBdV7UnH0q2tL3l/bttaKmvgbd/4916hUFEpDejYUSU73GEX5uvPdC2iEgvDHX63EhvAo59tTXX1F5bJLzwo47f0892qJdMREQkBCnAiUjf2ldAK9kCZVtbTglvEZCcASmj99HjZHDJP1uGoObgE0jbPkJQKIec937f8bT4ofy+REREBjAFOBHpWQ11UFrQcUArLeg4oI09zrv3vyVnQGS0d+zvpnYcSMaf0DfvL5RoWnwREZGwowAnIl3TnYCWfey+A1pnFEi6RtPii4iIhB0FOBFpaX8CWlK6F8bGHNN+QOupCTAUSLpO0+KLiIiEFQU4kYGmqwEN29uD1tsBLRAKJCIiIjKAKcCJhJuG+gACmv9kIP0soImIiIhIhxTgRIKtqwtT71dAaxrieJRfOBujgCYiIiISYhTgRIKp9cLUe/K87YodMPLgbga0ph60TAU0ERERkTChACcSTK/f0XJGRfC2X77Vr0EBTUREREQ8CnAiwbQnv+N9lz6rgCYiIiIiLSjAiQRLeTFEREFjXdt9g7Ng3Ky+rkhERERE+rmIYBcgMiDt2gB/PQUcENmqd00LU4uIiIhIBxTgRPra1k/gr1+H6hK48gU4+wGvxw3z7s+6T+uciYiIiEi7NIRSpC+tfxMWzoe4ITB/MQyfBFlHKLCJiIiISEDUAyfSVz5/Gp4431t/7apXvPAmIiIiItIFCnAifeGDP8Liq7zetite8JYFEBERERHpIg2hFOlNjY3w2s/h/ftg8lnwjYchOjbYVYmIiIhIiFKAE+ktDXXw7PXw2QLIuQpOvxsiIoNdlYiIiIiEMAU4kd5QUw6LLoX1r8MJP4WZPwKzYFclIiIiIiFOAU6kp1Xs8CYrKfzEWxLg8MuCXZGIiIiIhAkFOJGetHsT/OMbUFoA856AA08PdkUiIiIiEkYU4ER6SuFn8MR5UF8Dly6F0Ue0XqQqAAAgAElEQVQGuyIRERER6cCSFQXc/fIatpZUkZ4Sx82nTmLu9Ixgl9UpBTiRnrDhbVhwMcQOhque0xpvIiIiIv3YkhUF3PrM51TVNQBQUFLFrc98DtDvQ5zWgRPpri8Ww+PnwuBMLdAtIiIiEgLufnlNc3hrUlXXwN0vrwlSRYFTD5xId3z4ILx0C4z+GnzzKYgbEuyKRET6TKgOPxKRgau+oZE31xRTUFLV7v6tHbT3JwpwIvvDOXj9F/Du7+DAM+HchyE6LthViYj0mVAefiQiA8/GHRUsys1j8cf5FJXVEGHQ6Noel57S//+eU4AT6aqGOlh6I3z6JBx+BZzxv1qgW0QGlIZGx29eXN3u8KNfPLeSpNgokuOiSY6NJjkuiuTYaOIHRWJaD1NE+lBVbQMvflHIwuV5/HvjLiIMTjwwjQtysiirruOnS1a2+HcsLjqSm0/t/5fCKMCJdEVtBfzf5bD2FZj1Ezj+x1qgW0TCVm19I5t2VrCuqJy128tZW1TGuqJyNuyooLa+sd3n7K6s46rHctu0R0YYye0EuxaP46IZHNdyu2l/XLQCoIh0zjnHFwWlLFi+haWfbKWspp4xw+K5+dRJnHd4JiOSY5uPjYyICMlh4ApwIoGq2AlPng9bV8CZ90LOFcGuSESkR1TVNrC+uJx1Rd5tbVEZa4vK2byzkgbfGCMzyBwSx8S0JGYeMJxFuXmUVNa1OdeI5BgeuiSH0uo6Sqvqffd1bbb3VNWxvbSmeV91XfuBsElUhPkCXTshcJ/tCoAiA0FJZS1LVhSwMDef1YWlxERFcPrBo5g3I4sjxw5t9///udMzQiKwtaYAJxKI3Zvh8W/Anny44B8w+cxgVyQi0mVl1XW+gFbOet/92qIy8ndX4XzXgkRGGGOGxTMxLZHTpo5kYloSE9ISGT88kbhBe4eLTxmV3OIaOPCGH9162mQOyUrpcm019Q2UVdf7Al19u6Gv9fa20uqQCoCa9EWkZzU2Oj7YsJOFy/N4aeU2ausbmZqRzC/nTmXOIekMjosOdom9QgFOpDPbPveWCaivhkuWwJijgl2RiMg+7aqo3duTtr2c9cXeEMhtpdXNxwyKjGDc8AQOyUzhvMOymJCWyMQRiWQPS2BQVOerDDUFj54KJDFRkcQkRpKaGLNfz++PAdAbDuq1vfRFIT/55xea9EWkBxTuqeLp3HwWfZxH3q4qkmOj+OaMLC6YkcVB6YODXV6vM+famX4lyHJyclxubtvx8yJ9buO/YMFFEJME8xdD2uRgVyQiAnjXeRSV1fiuT/OGPDYNgdxZUdt8XPygSCakJTJheCITRiQ296hlDYkjKlLLwTbZnwDof1xnAbAjGSlxvHfLiT38bkTCT219I298uZ0Fy/N456tiGh0cPX4Y82ZkcepBI4mNDr8J5czsY+dcTut29cCJdGTlEnjm2zB0nBfeBmcGuyIRGYAaGx0FJVUtrk9rGgZZVl3ffFxybBQTRyRxypQRXmDz3dIHxxERoWu/OtPbPYB3vvhlu88rKKmiodERqf9GIu1aV1TGwuV5PPOfAnZW1DIyOZZrZ03ggpwsRg+LD3Z5QaEAJ9Kej/4CL9wMWUd6C3THDw12RSIS5uobGtmyq7JFT9raojLWF1W0uM4sNXEQE9ISmXtohjfsMc3rWRueGKNJOoKoswD4jw82d7hw8En/+xbXHD+ecw7LICYq/HoRRLqqoqae5z8rZGFuHh9v3k1UhHHS5DQunDGamQcMH/BfeGgIpYg/5+CNX8G/7oFJp8N5j2iBbhHpUTX1DWzaUdmiJ23d9nI27qigtmHvMLz0wbGMT/OGPE4ckdg8DHJIwqAgVi/7q/XC5wBx0RFceEQWuZtK+LxgDyOSY/j2ceO46MjRxA/Sd+wysDjnWJFXwqLleTz36VYqahsYNzyBC2dkcc70TIYn7V/veCjTEEqRzjTUw7KbYMXjcNhlcMZvIVL/i4jI/qmsrWdDcUXzRCJNvWqbd7Wcmn/0UG/Gx1kHDveb8TGBpNjwnD1toNrXpC/OOd5dt4MH3lzHr55fzQNvruOKY8Zy2VHZDI7X50DC266KWp75Tz4Ll+extqicuOhIzpzmTf9/+JghGlnQDvXAiQDUVvoW6H4Zjv9/MOtWLdAtIgEp9U3Nv257y+vT8nfvHS4XFWFkpyZ4wx19t4lpSYwbnhCWF97L/vt4827+9NY6XltdRMKgSOZ/bQxXHTuWNL/Fh0VCXUOj96XFwuVbeHXVduoaHIdmpTBvRhZnThulL7B8OuqBCyjAmdls4PdAJPCwc+7OVvt/AHwLqAeKgSudc5t9+xqAz32HbnHOzens9RTgpE9V7oInL4D8XDjjf2HGVcGuSESCZF/rdO0sr2lzfdq6onK2l9Y0Pz8mKoJxw73r0prC2sQRiYwZlkC0ZnyULlhdWMqf3lrPss+2EhUZwQU5mVw9czxZQwfmpA0SHvJ2VfJ/H+fzdG4eW/dUMyQ+mnOmZzJvRhaTRiYFu7x+Z78DnJlFAl8BpwD5wHLgm865VX7HnAD82zlXaWbfBWY55+b59pU75xK7UqwCnPSZki3wj2949+c+DFM6/X5BRMKUd43SZ1T5TQcfGWGMGRpPSVUdu/ym5k8YFMmEEUlMGO4FtKb7zCHxA/7ieulZm3ZU8Od3NrD443wanGPOIel8d9Z4DhihP3YlNNTUN/DKyu0sys3j3XU7ADhu4nDm5WRx8pQ0TdyzD90JcEcBtzvnTvVt3wrgnPtNB8dPB+53zh3j21aAk/5p+0pvge66SvjmAhhzdLArEpE+VFZdx1fby1izrZw120p56qO8FpOINBkUGcG5h2cwIS2puVdt1OBYXZchfWp7aTUP/2sDT/x7C5W1DZwyZQTXnTCBQ7NSgl2aSLu+3FbKwuV5/HNFASWVdWSkxHF+TibnHZ5J5hD1JAeiO5OYZAB5ftv5wJH7OP4q4EW/7Vgzy8UbXnmnc25JAK8p0rs2vQdPfRMGJcAVL8GIKcGuSER6SW19Ixt2lLNmW1nz7cttZS2mdE+MiWo3vAHUNTTym29M66tyRdo1IjmW/zpjCtfOmsCj72/i0fc38eqq9zhmwjCunTWBo8cP05cKEnRl1XU892khC5dv4dP8PQyKjOCUg0YwLyeLYyakaoRCDwkkwLX3k263287M5gM5wPF+zaOdc1vNbBzwhpl97pxb385zvwN8B2D06NEBlCWyn1Y9C4u/DUPGwPxnICUr2BWJSA9wzpG/u4qvtnsBrSmsbdhRTl2D92srKsIYPzyRw8cM4aIjRzNpRBKTRiaROSSOY//nzXbX6UpP0VIi0n8MSRjE9085gG/PHMdT/97CX/61gYsf/jeHZKVw3azxnDx5hBZulz7lnGP5pt0sXJ7HC58XUlXXwKQRSfzszCmcMz2DoVr6pMf12BBKMzsZ+ANwvHOuqINzPQosc849va/X1BBK6TXLH4bnfwSZM+CihVqgWyRElVTWNoc0776Ur7aXU15T33xMRkocB470AlrTbVxqIoOi2p9MpP11uiL5zTcObp7IRKS/qa5rYPF/8nnw7fXk7arigBGJXDtrAmdOG0WUJs6RXlRUVs0z/ylg0fI8NuyoIDEmirMOSWfejCwOyRysHuEe0J1r4KLwJjE5CSjAm8TkIufcSr9jpgNPA7Odc2v92ocAlc65GjNLBT4AzvafAKU9CnDS45yDN38N79wNB8yG8/4GgzT+WqS/q65rYF1ReXNIawptRWV7Z35MiY9u7kmbNDKJA0cmccCIpP2ahnpfs1CK9Gf1DY08/3khf3xzPWu2l5E1NI6rZ47nvMMztVSF9Jj6hkbe/qqYhcvzeP3LIhoaHTOyh3BBThZnTBulBeh7WHeXETgduBdvGYFHnHO/NrM7gFzn3FIzew04GCj0PWWLc26OmR0N/BloBCKAe51zf+3s9RTgpEc11MPz34f//B2mz4czf68FukX6mYZGx5ZdlS1C2pptZWzaWYFvzWsGRUUwMS2xOaRNGpnMgSOTSEuK0Te9Ij6NjY7XvyzigTfX8UleCcOTYvjWsWO5+GtjSIzR7z7ZP5t2VLAoN4/F/8lne2kNqYmDOPewTM7PyWJCWpfmKpQu6FaA62sKcNJjaith8VWw5gWYeTOc8F9aoFskiJxzFJfXtJhMZM22MtYWlVHtm77fDMYMjff1qCU3D4McMzReQ8JEAuSc44MNO/njm+t5d90OBsdFc9nR2VxxdDZDdE2SBKC6roEXvyhk4fI8PtywiwiDWZPSuCAni5Mmp2ltyz6gACcDT+UueOpCyPsITr8bjvh2sCsSGVAqaupZs91/5kfvOjX/9dRSE2NaXKd24MgkJqYlETdIQ75EesqneSX88a11vLxyO3HRkVx05Gi+fdw4Rg6ODXZp0g99UbCHhcvzWPJJAWXV9YweGs+8GVmce1imPjN9TAFOBpY9+d4C3bs3+hboPjvYFYmErbqGRjbuqGi+Tm3NtnLWbC8lb9feGR3jB0VywIiklpOKjEhiWGJMECsXGVi+2l7Gg2+t59lPtxJhcN7hmVw9czzZqQnBLk2CbE9lHc9+WsDC5Xms3FrKoKgITp86kgtmZPG1scM0s2mQKMDJwLF9lbdAd205fPMpyD422BWJhAXnHFv3VDdfp/aVbwjkhuKK5jXUIiOMcakJLSYTOXBkMplD4vQHgEg/kberkofe2cDC3DzqGxo5Y1o6184az+RRycEuTfpQY6Pjw407Wbg8j5e+2EZNfSMHpSczb0YWZx+SweD4rk8EJT1LAU4Ghs3ve8Mmo+Jg/mIYOTXYFYmEpD2Vdb4hj35rqm0vo6x67zT96YNjmTQyiQOaJhUZkcz4tARiojT8USQUFJVV88i7m3j8w82U19Rz4oFpXHfCeA4foyV2wtm2PdU8/XEei3Lz2bKrkqTYKOYemsG8GVlMzRgc7PLEjwKchL/Vy+DpKyFlNFzyjHcvMsB1Ni1+0zT9X21vOanIttLq5mOSYqP8hj4mN/esDY7Tt7Mi4WBPZR1//2ATj7y3kd2VdRw5dijXnjCBmRNTNcNrmKhraOT11UUsys3jrTVFNDr42rihXDhjNLOnjtRSE/2UApyEt9xH4PkfQvphcNEiSBgW7IpEgq69hakHRRonTR5BhBlfbitl085KGnzz9A+KjGB8WmKbSUVGJsfqjziRAaCytp4FH+Xx0Dsb2FZazdSMZK6bNYFTDxqpIdAhoL0v7A7OHMyi5d70/zvKa0lLiuH8nEzOPzxL1z6GAAU4CU/OwVt3wtt3wsRT4fy/wSD9gyQDS219I8XlNRSVVrO9tIbiMu/+kfc2Ulnb0O5zRvum6T/QL6iNGZagaaFFhNr6Rv65Ip8H397Axh0VjB+ewDXHj2fu9Az9G9FPtfeFXYRBo4OoCOPEA9OYNyOL4w8YruVYQogCnISfxgZ4/gfw8aNw6Hw4616I1JAuCR91DY0Ul9WwvVUwK/Ldby+tprishp1+0/I3afrF3R4DNt55Ru8WLyIhr6HR8eIXhTzw5npWF5aSkRLHd2aOY96MLA256yfqGhpZV1TORX/5kN2VdW32J8dG8doPjyctSdP/h6KOAlxUMIoR6ba6Klj8LfhyGRz3QzjxZ1qgW0KGfzArKtvbc1bUHNC8to6C2fCkGNKSYskcEsdhY4aQlhTDiORYRiR77WnJMQxLiGHmXW9SUFLV5hzpKXF98TZFJMRFRhhnTkvnjINH8dZXxTzwxjp+vnQlf3hjLVccM5ZLjhpDcqy+OO0rpdV1rN5ayqrCUlb57tduL2+eBbg9ZdX1Cm9hSAFOQk/lLnjqm5D3bzjtLjjy6mBXJALsDWZFTeHMF9C2l3YtmGWkxHJoVgojkr1g1hTQmoJZZIDXotx86qQ2Q2rioiO5+dRJPfaeRST8mRknTErjhElpfLRxFw+8uY67X17Dg2+t59Kjx3DFMWNJ1ZqOPaZpyZZVW5uC2h5WFbZcWzM1cRBT0gdz3MThTElP5lfLVlFUVtPmXPrCLjwpwElo2ZPvrfG2awOc9whM/UawK5IBoE0wa+41awpo3vauylpaj0qPMEhN9AKYfzBLS4ptEdCGJQYezALVNNvkvmahFBHpiiPGDuWIsUfwRcEe/vTWev741nr++u5GLpwxmm/PHEeGAkOXNA2BXNWqZ21PlTcc0gzGDktgWmYKF84YzZT0ZA5KT27Tq9bY6PSF3QCia+AkdBR9CY9/A2rK4MInYOzMYFckIa6uoZEd5TXN15O1F8yKy7wes30Fs7SkGNL8hjD63/dGMBMR6S/WF5fz57fX88x/CgA4Z3oG18waz/jhiUGurP8pra7jy8IyVm31etRWFZby1ba9QyBjoiI4cFQyU0YlMyXduz9wZBIJMYH1t3S2bIyEHk1iIqFty4fw5DyIivEt0H1wsCuSIAnkF5R/MCsqrWa7L5gVldawvaw6oGCWlhzDiKRY0vyGMCqYiYi0r6Ckir+8s4EFy7dQU9/IaVNHcu2sCQNyYWjnHIVNQyD9etW27KpsPmZYwiAvpPmC2kHpyWQPS9AMkdKCApyEri9fgKevgMGZMP8ZGDIm2BVJkLQ3TXJUhJEzZgixgyIp8k0EElgwawpjLQPa0IRB+gUqIrKfdpbX8Lf3NvHYB5soq67n+AOGc90JEzhi7NBgl9Yr6hoaWV9c7ne9mncrqWw5BHJy+t6etYNGJTM8KUbra0qnFOAkNH38KCz7PqRP9y3QnRrsiiSIjv7N62zdU92mPcJgSnpyi2DWFNT2Tv6hYCYi0ldKq+t4/MPNPPLuRnaU15IzZgjXnTCBWZOGh2xwKauuY3VnQyBHJjX3qk1JT+bAkckBD4EUaU0BTkKLc/D2XfDWf8OEU+CCx7RA9wCXu2kX5z34Qbv7tK6ZiEj/VF3XwKLcPP789gYKSqqYPCqZa2eN5/SDR/XbYeju/7d35+FRV4f+x98nIUDYkgDKEgiLIiqCAlFxqVqtF65WpdpaFZeqrbfe2vVeWrWLVltra3tv60+7uNX2aqWKiFr3pVZbqxVE2QQFFAj7FtaEbOf3x0QMmwmQ5JuZvF/Pw5OZk5nJJ8/zBeYz3/M9J0aWbyjf6azawjUfTYHs2rEtQ3pvf73agO5OgVTjssApfdRUw5P/DVPugcMvgDNvdYPuVmxjeSU/fXoO9722iOwQqN7Fv1mF+bn84+qTE0gnSWqIyuoaHn1rKb95aR7zV21mQPeOfPnEgXxmeB/atkmu9FRW17Bg1ebUUv11rlmruyn2gO4dtytqh/buwv5OgVQzsMApPVSWw8OXpzboPv6bcMp1btDdij07azk/eHQWKzaW84Vj+3Nwj85c//jsnZZJ/snZQ11pS5LSQE1N5NnZy7n9r/OZsWQ9Pbu050snDOT8o/rSoW3TTjXcWF7JnOUbtzuzNnfFRiqqdj8FcnDPLnRyCqQSYoFTy1dWmtqge9E/YczNMOrLSSdSQlZuKOe6x2bx1MzlHNyzMz85eyjDiwoAl0mWpEwQY+SV91bz65fm8dqCtRR0yOHS4wZwyTH9yeuwb7NuGjoFcsezagOdAqkWxgKnlm3D0tQG3avfg7N/B4edk3QiJaCmJvLnKYu56cl32FpVw9dPGcQVJwwkx/9QJSljTV24ll//dT4vzFlJx7bZXHhMPy4/fgCvzltT7wd2VdU1zK9nCmT/bh22K2qH9sqjRxenQKrls8Cp5Vo1F/7vbChfn9qge+CJSSdSAuav2sQ1k2bwr/fXcvSArvzk7KEMdCNYSWo13lm2gd+8NJ+/TF9KAAiB6pqP3qe2z8niihMG0r1Tu21lbc7yj6ZAtv1wCmTdjbB7OQVS6csCp5Zp8b/gT+dCVg5cOBF6HZ50IjWziqoa7nh5Pre+OI92bbL47mmHcG5xX7Ja6OpkkqSm9cHqzZx26ytsqaje7WMKOuQwpHeeUyCV0XZX4PxIQsmZ+xQ8dCl06ZXaoLvrgKQTqZlNW7SOaybNYM7yjZw2tCfXnzGE/bu0TzqWJClB/bt3pOxjyts/rzmZnl3aOwVSrZYFTsl484/w+DdSZ9wueBA67Zd0IjWjzVur+Pmzc7n31Q/o0bk9d15czKmH9kg6liSpheidn8uS0rKdxgvzc+mVl5tAIqnlsMCpecUIr/wcXvwRHHAKnPtHaOd1Tq3JX+es5HuTZ7J0fRkXHt2Pb48ZTOf27vMnSfrI+NGDuWbSjJ22jRk/enCCqaSWwQKn5lNTDU99B964E4adB2fd5gbdrcjqTVv54eOzefztpRy4fycmfvkYRvbrmnQsSVIL9OFqk24bI+3MAqfmUVkOj1wBsx+FY78Gn/ohZHmhcWsQY2Ti1BJ+/OQ7bN5axTc+NYgrTzqAdm2yk44mSWrBxg4vtLBJu2CBU9MrK4UJ42Dh32H0TXDMV5JOpGaycM1mrn1kBv+Yt4aR/Qq4+eyhDOrROelYkiRJacsCp6a1YVntBt3vwjl3w9DPJp1IzaCquoa7/v4+v3z+XdpkZXHj2MMYd1SRWwNIkiTtIwucGt/0B+GFG2B9CYQsyGoD4x6CAz6ZdDI1gxkl67l60nRmLd3AqYf24IazhrhimCRJUiOxwKlxTX8QHv8aVNYu/RurIbSBzauSzaUmt6Wiiv997l3u/vv7dOvUjt+MG8GYw3q6T48kSVIjssCpcb1ww0fl7UNVW1Pjw85NJpOa3MvvruK7k2eweG0Z5x/Vl6v//RDycl1hVJIkqbFZ4NS41pfs2bjS2trNFfzoL7OZNG0JA7t3ZMIVoxg1sFvSsSRJkjKWBU6Np7oKsttC9dadv5fXp/nzqMnEGHn0raXc8JfZbCir5KpPHshVJx9I+xy3BpAkSWpKFjg1nue+nypv2W2huuKj8ZxcOOUHyeVSo1q8dgvfmzyTv727iiP65nPzOUM5uGeXpGNJkiS1ChY4NY63HoDXfg1HXwmFIz5ahTKvT6q8ef1b2quuifz+H+/zi2ffJQS47oxDufiY/mS7NYAkSVKzscBp3y2ZCo9/Hfp/Av7tRsjOsbBlmNlLN3D1pOlML1nPJwfvx48+M5TCfLcGkCRJam4WOO2bjStgwoXQuQd87g+p8qaMUV5Zza9eeI87Xl5Afm4Ot54/nDOG9XJrAEmSpIRY4LT3qirgwYuhbB188Tno6OqDmeTV+au5dtIMPlizhc+O7MN3TzuEgo5tk44lSZLUqmU15EEhhDEhhLkhhHkhhKt38f1vhRBmhxCmhxBeCCH0q/O9S0II79X+uaQxwythT30bFr8GY2+HnkOTTqNGsn5LJd+e+DYX3Pk6NRHuu/xofv65wy1vkiRJLUC9Z+BCCNnA7cCpQAnwRgjhsRjj7DoPmwYUxxi3hBCuBH4GfD6E0BW4DigGIjC19rnrGvsXUTObcg9M/T0c/0047Jyk06gRxBh5YsYyrn9sNuu2VPAfJw7kG6ccRG5btwaQJElqKRoyhfIoYF6McQFACGECcBawrcDFGP9a5/GvARfW3h4NPBdjXFv73OeAMcAD+x5diVn4T3hyPBx4Kpz8/aTTqBEsLS3j+5Nn8sKclQwtzOPeS4/ksMK8pGNJkiRpBw0pcIXA4jr3S4CjP+bxlwNPfcxzC3f1pBDCFcAVAEVFRQ2IpUSsXwIPXgT5/eCcuyDLszPprLomct9rC/nZ03OojpHvnnYIlx7XnzbZDZpdLUmSpGbWkAK3q+Xm4i4fGMKFpKZLnrinz40x3gHcAVBcXLzLxyhhlWXw53FQWQ5feAJy85NOpH3w7oqNfOfh6UxbVMonBnXnx2OHUtStQ9KxJEmS9DEaUuBKgL517vcBlu74oBDCp4DvAifGGLfWee5JOzz3pb0JqoTFCI9/A5ZOg/MegP0GJ51Ie2lrVTW3vziP3/xtPp3ateF/zj2czwwvdGsASZKkNNCQAvcGMCiEMABYApwHXFD3ASGE4cDvgDExxpV1vvUMcFMIoaD2/r8B1+xzajW/134D0yfASdfCwaclnUZ76Y0P1nL1w9OZv2ozY4/ozfc/fSjdOrVLOpYkSZIaqN4CF2OsCiFcRaqMZQP3xBhnhRBuAKbEGB8DbgE6AQ/Vfoq/KMZ4ZoxxbQjhRlIlEOCGDxc0URpZ8BI8+z04+NNwwvik02gvbCiv5Oan5vCn1xdRmJ/LvZceyUmD9086liRJkvZQiLHlXW5WXFwcp0yZknQMAax9H+78JHTqmdqsu13npBNpDz09czk/eHQmqzdt5dLjBvCtUw+iY7uGnHyXJElSUkIIU2OMxTuO+y5Ou1exGSaMg1gD591veUszKzaU84NHZ/LMrBUc0qsLd15czOF9XXhGkiQpnVngtGsxwuT/hFXvwLiJ0O2ApBOpgWpqIg+8sYibn5xDRXUN3x4zmC99YiA5bg0gSZKU9ixw2rVXfgGzJ8OpN8KBpySdRg00b+Umrp00g399sJZjBnbjprOHMqB7x6RjSZIkqZFY4LSzd5+BF38Eh30Wjv1q0mnUABVVNfz2b/O57cV55LbN5mfnDONzxX3cGkCSJCnDWOC0vdXvwcNfhJ5D4cz/BxaAFm/qwnVcM2k6767YxKeH9eK6M4awX2e3BpAkScpEFjh9pHw9PHA+ZLeF8/4EbTsknUgfY9PWKm55eg5/fG0hPbu05+5LijnlkB5Jx5IkSVITssAppaYGJl0B696Hix+F/L5JJ9LHeOGdFXxv8kyWbyjn4lH9GD/mYDq5NYAkSVLG8x2fUl66Cd59Gk77OfQ/Puk02o1VG7dy/eOzeGL6Mg7q0YnbLjiWkf0Kko4lSZKkZmKBE8x+FF6+BYZfBEd+Mek02oUYIw9NKeHHT75DWUU13zr1IL584gG0bePWAJIkSa2JBa61WzELHrkS+hwJp//CRUtaoPdXb+baSTP454I1HNW/KzedPZQD9++UdCxJkiQlwALXmm1ZC5Qe10MAABMASURBVBMugHad4dz/gzauXNiSVFbXcOcrC/jV8+/RNjuLH3/mMM4/soisLEu2JElSa2WBa62qq2DipbBhKXzhSejSK+lEquPtxaVcPWkG7yzbwJghPfnhWUPo0aV90rEkSZKUMAtca/X8dbDgJTjzNuh7ZNJpWrXJ05ZwyzNzWVpaRs+89hzUoxOvvLea7p3a8dsLRzLmsJ5JR5QkSVILYYFrjaY/CP+8DY66AkZclHSaVm3ytCVcM2kGZZXVACxbX86y9eUcc0BXfnthMXm5OQknlCRJUkviEnatzdJp8NhXod/xMPqmpNO0alXVNalVJWvLW12L1pRZ3iRJkrQTz8C1JptWwoRx0HE/OPcPkG1BaE6lWyqYtqiUqQvXMXXhOt4uKWVLxc7lDWBpaVkzp5MkSVI6sMC1FlUV8OAlqZUnL38GOnZPOlFGq6mJzF+1iakL1/HmolRhm79qMwDZWYFDe3XhcyP78NjbS1m3pXKn5/fOz23uyJIkSUoDFrjW4umrYdGrcM7d0OvwpNNknE1bq3hrUem2sjZt0To2lFcBkN8hh5FFBZw9og8jigo4vG8eHdqm/uoNLyrY7ho4gNycbMaPHpzI7yFJkqSWzQLXGky9F6bcDcd+DYZ+Nuk0aS/GyKK1W7ZNhXxzUSlzl2+gJqb2QT9o/86cPqw3I4ryGdmvgAHdOxJ2s0H62OGFANtWoeydn8v40YO3jUuSJEl1hRhj0hl2UlxcHKdMmZJ0jMyw6HW493QYcAKMewiyspNOlHbKK6uZXrJ+u7NrqzdVANCpXRuGF+UzoqiAkf0KOKIony7tvbZQkiRJ+yaEMDXGWLzjuGfgMtmGpfDgRZDXBz57t+WtgZatL9vu7NqsJeupqkl90DGge0dOPGh/RvRLnV0btH9nsrN2fXZNkiRJamwWuExVWQ5/vhAqNsPFj0JuQdKJWqSKqhpmL9vAmwvXMXXROt5cuI5l68sBaJ+TxbA++XzphIGMLCpgeFE+3Tq1SzixJEmSWjMLXCaKEZ74FiyZCp+/H/Y/JOlELcbqTVu3lbVpC0t5u6SUrVU1ABTm51Lcv+u2a9cO6dWFnGy3SpQkSVLLYYHLRK//Dt66H068Gg75dNJpElNdE5m7fCNv1p5Zm7poHQvXbAEgJzswpHceF47qx8h+BYwoKqBnXvuEE0uSJEkfzwKXad5/GZ65FgafDid+J+k0zWp9WSXT6pS1txaVsrl2o+zundoxsl8+FxxVxMh+BRxWmEf7HK8JlCRJUnqxwGWSdQtTm3V3OxA+81vIytzpfzFG5q/azJt1Nsp+b+UmALICHNyzC2eP6LPt7Frfrrm7XcpfkiRJShcWuExRsRkmjIOaajj/AWjfJelEjWrz1ireLilNnV1buI5pi0sp3VIJQF5uDiOK8jnz8N6M7FfAsL75dGrnoS1JkqTM47vcTBAjPHoVrJgJ4yZCtwOSTrRPYoyUrCurXcY/VdjeWZbaKBvgwP07MfrQnqmza/3yGdi9E1ku5S9JkqRWwAKXCf7xS5g1CT51PQz6VNJp9lh5ZTWzlq7fbu+1VRu3AtCxbTZHFOXzlU8eyIh+BYzoW0BeBzfKliRJUutkgUt37z0Hz/8QhpwNx30j6TQATJ62hFuemcvS0jJ65+cyfvRgxg4v3Pb9FRvKU0WtdrGRWUs2UFGdWsq/qGsHjj+we6qsFeUzuEdn2riUvyRJkgRY4NLbmvkw8XLocRicdRu0gEU6Jk9bwjWTZlBWmVr9cUlpGd95eDovv7uSyhp4c+E6lpSWAdC2TRaH98nj0uP61xa2Avbr7EbZkiRJ0u5Y4NJV+QZ44HzIbgPn3Q9tOyadCICfPj1nW3n70NaqGiZNW0rPLu0Z2a+Ay44fwIiifIb0zqNtG8+uSZIkSQ1lgUtHNTXwyH/Amnlw8WQo6JdYlM1bq5i6cB2vLVjDawvWsGx9+S4fF4DXrj2lecNJkiRJGcYCl47+9lOY+ySM+SkMOKFZf/SWiiqmfPBRYZtesp6qmkibrMCwPnl0ateGTVurdnpe7/zcZs0pSZIkZSILXLp553H4281wxDg4+j+a/Mdtqah7hm0tby8upaomkl1b2L50wkBGDexGcb8COrZrs9M1cAC5OdmMHz24ybNKkiRJmc4Cl05WvgOPfBkKR8Lp/9Mki5bsaWHb0YerTX7cKpSSJEmS9o4FLl2UrUstWtK2I3z+Pshp3ygv29DCNrJfAZ12Udh2ZezwQgubJEmS1AQscOmgphomXgbrS+ALT0CX3nv9Uk1R2CRJkiQ1D9+hp4Pnr4f5L8IZt0LR0Xv01C0VVby5sHTboiNvl5RSWZ0qbEML8/jiJwYyamBXivt3tbBJkiRJLVyD3rGHEMYAvwKygbtijDfv8P0TgF8Cw4DzYowT63yvGphRe3dRjPHMxgjeakx/CF69FYovh5GX1Pvwsorq7Zb137GwXX68hU2SJElKV/W+gw8hZAO3A6cCJcAbIYTHYoyz6zxsEfAF4L938RJlMcYjGiFr67P0LXjsKig6FsbcvMuHWNgkSZKk1qMh7+iPAubFGBcAhBAmAGcB2wpcjPGD2u/VNEHG1mnTKvjzhdChG5z7R2jTFrCwSZIkSa1ZQ97hFwKL69wvAfbkQqz2IYQpQBVwc4xx8q4eFEK4ArgCoKioaA9ePgNVV8JDl8DmVZRf9CRTlwdeWzCX1xas4a3FHxW2wwrzuOz4AduW9e/cPifp5JIkSZKaUEMK3K42G4t78DOKYoxLQwgDgRdDCDNijPN3esEY7wDuACguLt6T188oZRXVrHv4m/Re+A9+lTee2+5YQWX1cgubJEmSpAYVuBKgb537fYClDf0BMcaltV8XhBBeAoYDOxW41qqsopo3F300JfLAkkf4SZv/486q03mx7Se57PiuFjZJkiRJQMMK3BvAoBDCAGAJcB5wQUNePIRQAGyJMW4NIXQHjgN+trdhM0F5ZTVv1tmH7a3FpVRU15AV4Jwey7kx5/es7XEc5118N1/qkJt0XEmSJEktSL0FLsZYFUK4CniG1DYC98QYZ4UQbgCmxBgfCyEcCTwCFABnhBB+GGMcAhwC/K52cZMsUtfAzd7Nj8pIH1fYhhbmcelx/Rk1sBtHdiun0x++BfmFdL34PrC8SZIkSdpBiLHlXW5WXFwcp0yZknSMvVJfYRs1sFtqSmT/OlMiq7bCvafDitnwxeegx5BkfwlJkiRJiQohTI0xFu847jrzDTB52hJueWYuS0vL6J2fy/jRgxk7vBBo+Bm27QpbXTHCE9+CkjdS2wVY3iRJkiTthgWuHpOnLeGaSTMoq6wGYElpGd9+eDpPzVjGurJK3lq068I2sn8BXRqy6Mgbd8G0++CE8XDoWU3820iSJElKZxa4etzyzNxt5e1DFVU1PDN7BcP65PGF4/pv2zi7QYWtrg/+Dk9fDQeNgZOubcTUkiRJkjKRBa4eS0vLdjkegMeuOn7vX7h0ETx4MRQMgLPvgKysvX8tSZIkSa2CraEevfN3vRrk7sYbpGILTBgH1ZVw/gPQPm/vX0uSJElSq2GBq8f40YPJzcnebiw3J5vxowfv3QvGCI99FZbPgHPugu6DGiGlJEmSpNbAKZT1+HC1yd2tQrnHXr0VZk6Ek78PB41uxKSSJEmSMp0FrgHGDi/c+8JW17zn4fnr4dCx8In/2vfXkyRJktSqOIWyuayZDxMvg/0OgbG/hhCSTiRJkiQpzVjgmsPWjTDhAghZcP6foG3HpBNJkiRJSkNOoWxqNTXwyJdh9Xtw0SQo6J90IkmSJElpygLX1F6+Beb8BUb/BAaelHQaSZIkSWnMKZRNac4T8NJNMOw8GHVl0mkkSZIkpTkLXFNZOQcmXQG9h8MZv3TREkmSJEn7zALXFMpKU4uW5OTC5+9PfZUkSZKkfeQ1cI2tphoevhxKF8Elj0NeI+wfJ0mSJElY4BrfizemNuz+9P9Cv2OSTiNJkiQpgziFsjHNfBj+/r8w8lIovizpNJIkSZIyjAWusSybDpO/An1Hwb//LOk0kiRJkjKQBa4xbF4DE8ZBbgGc+0do0zbpRJIkSZIykNfA7avqSnjoEti0Ai57Cjr3SDqRJEmSpAxlgdtXz34PPngFxv4WCkcmnUaSJElSBnMK5b6Ydj+8/lsY9Z9wxPlJp5EkSZKU4Sxwe6tkKvzlmzDgRDj1xqTTSJIkSWoFLHB7Y+Ny+PO41PVun7sXsp2JKkmSJKnp2Tz2VNVW+PNFUL4eLn8OOnRNOpEkSZKkVsICtydihCfHQ8m/Umfeeh6WdCJJkiRJrYgFriGmPwgv3ADrF6fuDz4Nhnwm2UySJEmSWh2vgavP9Afh8a99VN4AFvw1NS5JkiRJzcgCV58XboDKsu3HKstS45IkSZLUjCxw9VlfsmfjkiRJktRELHD1yeuzZ+OSJEmS1EQscPU55QeQk7v9WE5ualySJEmSmpEFrj7DzoUzboW8vkBIfT3j1tS4JEmSJDUjtxFoiGHnWtgkSZIkJc4zcJIkSZKUJixwkiRJkpQmLHCSJEmSlCYscJIkSZKUJixwkiRJkpQmLHCSJEmSlCZCjDHpDDsJIawCFiadYxe6A6uTDqGM5fGlpuTxpabk8aWm5PGlptZSj7F+Mcb9dhxskQWupQohTIkxFiedQ5nJ40tNyeNLTcnjS03J40tNLd2OMadQSpIkSVKasMBJkiRJUpqwwO2ZO5IOoIzm8aWm5PGlpuTxpabk8aWmllbHmNfASZIkSVKa8AycJEmSJKUJC5wkSZIkpQkLXAOEEMaEEOaGEOaFEK5OOo8yRwihbwjhryGEd0IIs0IIX086kzJPCCE7hDAthPCXpLMo84QQ8kMIE0MIc2r/LTsm6UzKHCGEb9b+/zgzhPBACKF90pmUvkII94QQVoYQZtYZ6xpCeC6E8F7t14IkMzaEBa4eIYRs4Hbg34FDgfNDCIcmm0oZpAr4rxjjIcAo4CseX2oCXwfeSTqEMtavgKdjjAcDh+OxpkYSQigEvgYUxxgPA7KB85JNpTR3LzBmh7GrgRdijIOAF2rvt2gWuPodBcyLMS6IMVYAE4CzEs6kDBFjXBZjfLP29kZSb3wKk02lTBJC6AOcDtyVdBZlnhBCF+AE4G6AGGNFjLE02VTKMG2A3BBCG6ADsDThPEpjMcaXgbU7DJ8F/KH29h+Asc0aai9Y4OpXCCyuc78E32CrCYQQ+gPDgdeTTaIM80vg20BN0kGUkQYCq4Df107TvSuE0DHpUMoMMcYlwM+BRcAyYH2M8dlkUykD9YgxLoPUB+vA/gnnqZcFrn5hF2PuvaBGFULoBDwMfCPGuCHpPMoMIYRPAytjjFOTzqKM1QYYAfwmxjgc2EwaTD9Seqi9FuksYADQG+gYQrgw2VRS8ixw9SsB+ta53wdP36sRhRBySJW3+2OMk5LOo4xyHHBmCOEDUtO/Tw4h3JdsJGWYEqAkxvjhzIGJpAqd1Bg+BbwfY1wVY6wEJgHHJpxJmWdFCKEXQO3XlQnnqZcFrn5vAINCCANCCG1JXTz7WMKZlCFCCIHUtSPvxBj/J+k8yiwxxmtijH1ijP1J/dv1YozRT6/VaGKMy4HFIYTBtUOnALMTjKTMsggYFULoUPv/5Sm4SI4a32PAJbW3LwEeTTBLg7RJOkBLF2OsCiFcBTxDavWje2KMsxKOpcxxHHARMCOE8Fbt2LUxxicTzCRJe+KrwP21H3IuAC5NOI8yRIzx9RDCROBNUqs2TwPuSDaV0lkI4QHgJKB7CKEEuA64GXgwhHA5qQ8NPpdcwoYJMXo5lyRJkiSlA6dQSpIkSVKasMBJkiRJUpqwwEmSJElSmrDASZIkSVKasMBJkiRJUpqwwEmSMlYIoTqE8FadP1c34mv3DyHMbKzXkySpIdwHTpKUycpijEckHUKSpMbiGThJUqsTQvgghPDTEMK/av8cWDveL4TwQghheu3XotrxHiGER0IIb9f+Obb2pbJDCHeGEGaFEJ4NIeQm9ktJkloFC5wkKZPl7jCF8vN1vrchxngUcBvwy9qx24A/xhiHAfcDt9aO3wr8LcZ4ODACmFU7Pgi4PcY4BCgFzmni30eS1MqFGGPSGSRJahIhhE0xxk67GP8AODnGuCCEkAMsjzF2CyGsBnrFGCtrx5fFGLuHEFYBfWKMW+u8Rn/guRjjoNr73wFyYow/avrfTJLUWnkGTpLUWsXd3N7dY3Zla53b1XhtuSSpiVngJEmt1efrfP1n7e1XgfNqb48D/l57+wXgSoAQQnYIoUtzhZQkqS4/KZQkZbLcEMJbde4/HWP8cCuBdiGE10l9mHl+7djXgHtCCOOBVcClteNfB+4IIVxO6kzblcCyJk8vSdIOvAZOktTq1F4DVxxjXJ10FkmS9oRTKCVJkiQpTXgGTpIkSZLShGfgJEmSJClNWOAkSZIkKU1Y4CRJkiQpTVjgJEmSJClNWOAkSZIkKU38fw/wqArUCGzCAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.plot(solver.loss_history, 'o', label='baseline')\n",
    "plt.plot(bn_solver.loss_history, 'o', label='batchnorm')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.plot(solver.train_acc_history, '-o', label='baseline')\n",
    "plt.plot(bn_solver.train_acc_history, '-o', label='batchnorm')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.plot(solver.val_acc_history, '-o', label='baseline')\n",
    "plt.plot(bn_solver.val_acc_history, '-o', label='batchnorm')\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 批处理规范化和初始化\n",
    "现在，我们将进行一个小实验来研究批处理规范化和权值初始化之间的相互作用。\n",
    "第一个单元将训练8层网络，使用不同规模的权重初始化进行批处理规范化和不进行批处理规范化。第二层将绘制训练精度、验证集精度、训练损失作为权重初始化量表的函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running weight scale 1 / 20\n",
      "Running weight scale 2 / 20\n",
      "Running weight scale 3 / 20\n",
      "Running weight scale 4 / 20\n",
      "Running weight scale 5 / 20\n",
      "Running weight scale 6 / 20\n",
      "Running weight scale 7 / 20\n",
      "Running weight scale 8 / 20\n",
      "Running weight scale 9 / 20\n",
      "Running weight scale 10 / 20\n",
      "Running weight scale 11 / 20\n",
      "Running weight scale 12 / 20\n",
      "Running weight scale 13 / 20\n",
      "Running weight scale 14 / 20\n",
      "Running weight scale 15 / 20\n",
      "Running weight scale 16 / 20\n",
      "Running weight scale 17 / 20\n",
      "Running weight scale 18 / 20\n",
      "Running weight scale 19 / 20\n",
      "Running weight scale 20 / 20\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [50, 50, 50, 50, 50, 50, 50]\n",
    "\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "bn_solvers = {}\n",
    "solvers = {}\n",
    "weight_scales = np.logspace(-4, 0, num=20)\n",
    "for i, weight_scale in enumerate(weight_scales):\n",
    "  print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n",
    "  bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=True)\n",
    "  model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=False)\n",
    "\n",
    "  bn_solver = Solver(bn_model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  bn_solver.train()\n",
    "  bn_solvers[weight_scale] = bn_solver\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  solver.train()\n",
    "  solvers[weight_scale] = solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results of weight scale experiment\n",
    "best_train_accs, bn_best_train_accs = [], []\n",
    "best_val_accs, bn_best_val_accs = [], []\n",
    "final_train_loss, bn_final_train_loss = [], []\n",
    "\n",
    "for ws in weight_scales:\n",
    "  best_train_accs.append(max(solvers[ws].train_acc_history))\n",
    "  bn_best_train_accs.append(max(bn_solvers[ws].train_acc_history))\n",
    "  \n",
    "  best_val_accs.append(max(solvers[ws].val_acc_history))\n",
    "  bn_best_val_accs.append(max(bn_solvers[ws].val_acc_history))\n",
    "  \n",
    "  final_train_loss.append(np.mean(solvers[ws].loss_history[-100:]))\n",
    "  bn_final_train_loss.append(np.mean(bn_solvers[ws].loss_history[-100:]))\n",
    "  \n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Best val accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best val accuracy')\n",
    "plt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\n",
    "plt.legend(ncol=2, loc='lower right')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Best train accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best training accuracy')\n",
    "plt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Final training loss vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Final training loss')\n",
    "plt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "plt.gca().set_ylim(1.0, 3.5)\n",
    "\n",
    "plt.gcf().set_size_inches(10, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question:\n",
    "描述一下这个实验的结果，并试着给出一个为什么这个实验得出这样的结果的原因。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answer:\n",
    "批处理的归一化使得各层的输入值不是太小或者太大，不至于造成梯度消失或者爆炸，在反向传播时网络可以得到更好的梯度，同时使得初始化的权重可以更加随意的取值，不至于发生严重意外。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3.7.6 64-bit ('base': conda)",
   "language": "python",
   "name": "python37664bitbaseconda92b0ec200685491790e4a861efae1222"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
